# include <vector>
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-static_assert( VK_HEADER_VERSION == 41 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 42 , "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
eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
- eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR
+ eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
+ eErrorInvalidExternalHandleKHX = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX
};
VULKAN_HPP_INLINE std::string to_string(Result value)
case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
case Result::eErrorOutOfPoolMemoryKHR: return "ErrorOutOfPoolMemoryKHR";
+ case Result::eErrorInvalidExternalHandleKHX: return "ErrorInvalidExternalHandleKHX";
default: return "invalid";
}
}
return PipelineShaderStageCreateFlags( bit0 ) | bit1;
}
- enum class DescriptorSetLayoutCreateFlagBits
- {
- };
-
- using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
-
- VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
- {
- return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
- }
-
enum class BufferViewCreateFlagBits
{
};
return MemoryMapFlags( bit0 ) | bit1;
}
- enum class SubpassDescriptionFlagBits
- {
- };
-
- using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
-
- VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
- {
- return SubpassDescriptionFlags( bit0 ) | bit1;
- }
-
enum class DescriptorPoolResetFlagBits
{
};
return DescriptorPoolResetFlags( bit0 ) | bit1;
}
- enum class SwapchainCreateFlagBitsKHR
+ enum class DescriptorUpdateTemplateCreateFlagBitsKHR
{
};
- using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
+ using DescriptorUpdateTemplateCreateFlagsKHR = Flags<DescriptorUpdateTemplateCreateFlagBitsKHR, VkDescriptorUpdateTemplateCreateFlagsKHR>;
- VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ VULKAN_HPP_INLINE DescriptorUpdateTemplateCreateFlagsKHR operator|( DescriptorUpdateTemplateCreateFlagBitsKHR bit0, DescriptorUpdateTemplateCreateFlagBitsKHR bit1 )
{
- return SwapchainCreateFlagsKHR( bit0 ) | bit1;
+ return DescriptorUpdateTemplateCreateFlagsKHR( bit0 ) | bit1;
}
enum class DisplayModeCreateFlagBitsKHR
}
#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ enum class IOSSurfaceCreateFlagBitsMVK
+ {
+ };
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
+
+ VULKAN_HPP_INLINE IOSSurfaceCreateFlagsMVK operator|( IOSSurfaceCreateFlagBitsMVK bit0, IOSSurfaceCreateFlagBitsMVK bit1 )
+ {
+ return IOSSurfaceCreateFlagsMVK( bit0 ) | bit1;
+ }
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ enum class MacOSSurfaceCreateFlagBitsMVK
+ {
+ };
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
+
+ VULKAN_HPP_INLINE MacOSSurfaceCreateFlagsMVK operator|( MacOSSurfaceCreateFlagBitsMVK bit0, MacOSSurfaceCreateFlagBitsMVK bit1 )
+ {
+ return MacOSSurfaceCreateFlagsMVK( bit0 ) | bit1;
+ }
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
enum class CommandPoolTrimFlagBitsKHR
{
};
return CommandPoolTrimFlagsKHR( bit0 ) | bit1;
}
+ enum class PipelineViewportSwizzleStateCreateFlagBitsNV
+ {
+ };
+
+ using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>;
+
+ VULKAN_HPP_INLINE PipelineViewportSwizzleStateCreateFlagsNV operator|( PipelineViewportSwizzleStateCreateFlagBitsNV bit0, PipelineViewportSwizzleStateCreateFlagBitsNV bit1 )
+ {
+ return PipelineViewportSwizzleStateCreateFlagsNV( bit0 ) | bit1;
+ }
+
+ enum class PipelineDiscardRectangleStateCreateFlagBitsEXT
+ {
+ };
+
+ using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>;
+
+ VULKAN_HPP_INLINE PipelineDiscardRectangleStateCreateFlagsEXT operator|( PipelineDiscardRectangleStateCreateFlagBitsEXT bit0, PipelineDiscardRectangleStateCreateFlagBitsEXT bit1 )
+ {
+ return PipelineDiscardRectangleStateCreateFlagsEXT( bit0 ) | bit1;
+ }
+
class DeviceMemory
{
public:
};
static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
+ class DescriptorUpdateTemplateKHR
+ {
+ public:
+ DescriptorUpdateTemplateKHR()
+ : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE)
+ {}
+
+ DescriptorUpdateTemplateKHR( std::nullptr_t )
+ : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE)
+ {}
+
+ VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR)
+ : m_descriptorUpdateTemplateKHR(descriptorUpdateTemplateKHR)
+ {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+ DescriptorUpdateTemplateKHR& operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR)
+ {
+ m_descriptorUpdateTemplateKHR = descriptorUpdateTemplateKHR;
+ return *this;
+ }
+#endif
+
+ DescriptorUpdateTemplateKHR& operator=( std::nullptr_t )
+ {
+ m_descriptorUpdateTemplateKHR = VK_NULL_HANDLE;
+ return *this;
+ }
+
+ bool operator==(DescriptorUpdateTemplateKHR const &rhs) const
+ {
+ return m_descriptorUpdateTemplateKHR == rhs.m_descriptorUpdateTemplateKHR;
+ }
+
+ bool operator!=(DescriptorUpdateTemplateKHR const &rhs) const
+ {
+ return m_descriptorUpdateTemplateKHR != rhs.m_descriptorUpdateTemplateKHR;
+ }
+
+ bool operator<(DescriptorUpdateTemplateKHR const &rhs) const
+ {
+ return m_descriptorUpdateTemplateKHR < rhs.m_descriptorUpdateTemplateKHR;
+ }
+
+ VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplateKHR() const
+ {
+ return m_descriptorUpdateTemplateKHR;
+ }
+
+ explicit operator bool() const
+ {
+ return m_descriptorUpdateTemplateKHR != VK_NULL_HANDLE;
+ }
+
+ bool operator!() const
+ {
+ return m_descriptorUpdateTemplateKHR == VK_NULL_HANDLE;
+ }
+
+ private:
+ VkDescriptorUpdateTemplateKHR m_descriptorUpdateTemplateKHR;
+ };
+ static_assert( sizeof( DescriptorUpdateTemplateKHR ) == sizeof( VkDescriptorUpdateTemplateKHR ), "handle and wrapper have different size!" );
+
class DisplayKHR
{
public:
};
static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
+ struct ViewportWScalingNV
+ {
+ ViewportWScalingNV( float xcoeff_ = 0, float ycoeff_ = 0 )
+ : xcoeff( xcoeff_ )
+ , ycoeff( ycoeff_ )
+ {
+ }
+
+ ViewportWScalingNV( VkViewportWScalingNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ViewportWScalingNV) );
+ }
+
+ ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ViewportWScalingNV) );
+ return *this;
+ }
+
+ ViewportWScalingNV& setXcoeff( float xcoeff_ )
+ {
+ xcoeff = xcoeff_;
+ return *this;
+ }
+
+ ViewportWScalingNV& setYcoeff( float ycoeff_ )
+ {
+ ycoeff = ycoeff_;
+ return *this;
+ }
+
+ operator const VkViewportWScalingNV&() const
+ {
+ return *reinterpret_cast<const VkViewportWScalingNV*>(this);
+ }
+
+ bool operator==( ViewportWScalingNV const& rhs ) const
+ {
+ return ( xcoeff == rhs.xcoeff )
+ && ( ycoeff == rhs.ycoeff );
+ }
+
+ bool operator!=( ViewportWScalingNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ float xcoeff;
+ float ycoeff;
+ };
+ static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
+
enum class ImageLayout
{
eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
};
static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
- enum class QueryType
- {
- eOcclusion = VK_QUERY_TYPE_OCCLUSION,
- ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
- eTimestamp = VK_QUERY_TYPE_TIMESTAMP
- };
-
- enum class BorderColor
- {
- eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
- eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
- eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
- eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
- eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
- eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
- };
-
- enum class PipelineBindPoint
- {
- eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
- eCompute = VK_PIPELINE_BIND_POINT_COMPUTE
- };
-
- struct SubpassDescription
+ struct DescriptorUpdateTemplateEntryKHR
{
- SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, uint32_t inputAttachmentCount_ = 0, const AttachmentReference* pInputAttachments_ = nullptr, uint32_t colorAttachmentCount_ = 0, const AttachmentReference* pColorAttachments_ = nullptr, const AttachmentReference* pResolveAttachments_ = nullptr, const AttachmentReference* pDepthStencilAttachment_ = nullptr, uint32_t preserveAttachmentCount_ = 0, const uint32_t* pPreserveAttachments_ = nullptr )
- : flags( flags_ )
- , pipelineBindPoint( pipelineBindPoint_ )
- , inputAttachmentCount( inputAttachmentCount_ )
- , pInputAttachments( pInputAttachments_ )
- , colorAttachmentCount( colorAttachmentCount_ )
- , pColorAttachments( pColorAttachments_ )
- , pResolveAttachments( pResolveAttachments_ )
- , pDepthStencilAttachment( pDepthStencilAttachment_ )
- , preserveAttachmentCount( preserveAttachmentCount_ )
- , pPreserveAttachments( pPreserveAttachments_ )
- {
- }
-
- SubpassDescription( VkSubpassDescription const & rhs )
- {
- memcpy( this, &rhs, sizeof(SubpassDescription) );
- }
-
- SubpassDescription& operator=( VkSubpassDescription const & rhs )
- {
- memcpy( this, &rhs, sizeof(SubpassDescription) );
- return *this;
- }
-
- SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ DescriptorUpdateTemplateEntryKHR( uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, size_t offset_ = 0, size_t stride_ = 0 )
+ : dstBinding( dstBinding_ )
+ , dstArrayElement( dstArrayElement_ )
+ , descriptorCount( descriptorCount_ )
+ , descriptorType( descriptorType_ )
+ , offset( offset_ )
+ , stride( stride_ )
{
- pipelineBindPoint = pipelineBindPoint_;
- return *this;
}
- SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
+ DescriptorUpdateTemplateEntryKHR( VkDescriptorUpdateTemplateEntryKHR const & rhs )
{
- inputAttachmentCount = inputAttachmentCount_;
- return *this;
+ memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) );
}
- SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
+ DescriptorUpdateTemplateEntryKHR& operator=( VkDescriptorUpdateTemplateEntryKHR const & rhs )
{
- pInputAttachments = pInputAttachments_;
+ memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) );
return *this;
}
- SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
+ DescriptorUpdateTemplateEntryKHR& setDstBinding( uint32_t dstBinding_ )
{
- colorAttachmentCount = colorAttachmentCount_;
+ dstBinding = dstBinding_;
return *this;
}
- SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
+ DescriptorUpdateTemplateEntryKHR& setDstArrayElement( uint32_t dstArrayElement_ )
{
- pColorAttachments = pColorAttachments_;
+ dstArrayElement = dstArrayElement_;
return *this;
}
- SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
+ DescriptorUpdateTemplateEntryKHR& setDescriptorCount( uint32_t descriptorCount_ )
{
- pResolveAttachments = pResolveAttachments_;
+ descriptorCount = descriptorCount_;
return *this;
}
- SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
+ DescriptorUpdateTemplateEntryKHR& setDescriptorType( DescriptorType descriptorType_ )
{
- pDepthStencilAttachment = pDepthStencilAttachment_;
+ descriptorType = descriptorType_;
return *this;
}
- SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
+ DescriptorUpdateTemplateEntryKHR& setOffset( size_t offset_ )
{
- preserveAttachmentCount = preserveAttachmentCount_;
+ offset = offset_;
return *this;
}
- SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
+ DescriptorUpdateTemplateEntryKHR& setStride( size_t stride_ )
{
- pPreserveAttachments = pPreserveAttachments_;
+ stride = stride_;
return *this;
}
- operator const VkSubpassDescription&() const
+ operator const VkDescriptorUpdateTemplateEntryKHR&() const
{
- return *reinterpret_cast<const VkSubpassDescription*>(this);
+ return *reinterpret_cast<const VkDescriptorUpdateTemplateEntryKHR*>(this);
}
- bool operator==( SubpassDescription const& rhs ) const
+ bool operator==( DescriptorUpdateTemplateEntryKHR const& rhs ) const
{
- return ( flags == rhs.flags )
- && ( pipelineBindPoint == rhs.pipelineBindPoint )
- && ( inputAttachmentCount == rhs.inputAttachmentCount )
- && ( pInputAttachments == rhs.pInputAttachments )
- && ( colorAttachmentCount == rhs.colorAttachmentCount )
- && ( pColorAttachments == rhs.pColorAttachments )
- && ( pResolveAttachments == rhs.pResolveAttachments )
- && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
- && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
- && ( pPreserveAttachments == rhs.pPreserveAttachments );
+ return ( dstBinding == rhs.dstBinding )
+ && ( dstArrayElement == rhs.dstArrayElement )
+ && ( descriptorCount == rhs.descriptorCount )
+ && ( descriptorType == rhs.descriptorType )
+ && ( offset == rhs.offset )
+ && ( stride == rhs.stride );
}
- bool operator!=( SubpassDescription const& rhs ) const
+ bool operator!=( DescriptorUpdateTemplateEntryKHR const& rhs ) const
{
return !operator==( rhs );
}
- SubpassDescriptionFlags flags;
- PipelineBindPoint pipelineBindPoint;
- uint32_t inputAttachmentCount;
- const AttachmentReference* pInputAttachments;
- uint32_t colorAttachmentCount;
- const AttachmentReference* pColorAttachments;
- const AttachmentReference* pResolveAttachments;
- const AttachmentReference* pDepthStencilAttachment;
- uint32_t preserveAttachmentCount;
- const uint32_t* pPreserveAttachments;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ DescriptorType descriptorType;
+ size_t offset;
+ size_t stride;
};
- static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DescriptorUpdateTemplateEntryKHR ) == sizeof( VkDescriptorUpdateTemplateEntryKHR ), "struct and wrapper have different size!" );
- enum class PipelineCacheHeaderVersion
+ enum class QueryType
{
- eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+ eOcclusion = VK_QUERY_TYPE_OCCLUSION,
+ ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
+ eTimestamp = VK_QUERY_TYPE_TIMESTAMP
};
- enum class PrimitiveTopology
+ enum class BorderColor
{
- ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
- eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
- eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
+ eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+ eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
+ eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
+ eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+ eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
+ eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
+ };
+
+ enum class PipelineBindPoint
+ {
+ eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
+ eCompute = VK_PIPELINE_BIND_POINT_COMPUTE
+ };
+
+ enum class PipelineCacheHeaderVersion
+ {
+ eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+ };
+
+ enum class PrimitiveTopology
+ {
+ ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+ eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
+ eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
+ eRenderPassMultiviewCreateInfoKHX = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX,
+ ePhysicalDeviceMultiviewFeaturesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX,
+ ePhysicalDeviceMultiviewPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX,
eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR,
eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR,
ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR,
+ eMemoryAllocateFlagsInfoKHX = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX,
+ eBindBufferMemoryInfoKHX = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX,
+ eBindImageMemoryInfoKHX = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX,
+ eDeviceGroupRenderPassBeginInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX,
+ eDeviceGroupCommandBufferBeginInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX,
+ eDeviceGroupSubmitInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX,
+ eDeviceGroupBindSparseInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX,
+ eDeviceGroupPresentCapabilitiesKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX,
+ eImageSwapchainCreateInfoKHX = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX,
+ eBindImageMemorySwapchainInfoKHX = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX,
+ eAcquireNextImageInfoKHX = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX,
+ eDeviceGroupPresentInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX,
+ eDeviceGroupSwapchainCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX,
eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
+ ePhysicalDeviceGroupPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX,
+ eDeviceGroupDeviceCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX,
+ ePhysicalDeviceExternalImageFormatInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX,
+ eExternalImageFormatPropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX,
+ ePhysicalDeviceExternalBufferInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX,
+ eExternalBufferPropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX,
+ ePhysicalDeviceIdPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX,
+ ePhysicalDeviceProperties2KHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX,
+ eImageFormatProperties2KHX = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX,
+ ePhysicalDeviceImageFormatInfo2KHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX,
+ eExternalMemoryBufferCreateInfoKHX = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX,
+ eExternalMemoryImageCreateInfoKHX = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX,
+ eExportMemoryAllocateInfoKHX = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX,
+ eImportMemoryWin32HandleInfoKHX = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX,
+ eExportMemoryWin32HandleInfoKHX = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX,
+ eMemoryWin32HandlePropertiesKHX = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX,
+ eImportMemoryFdInfoKHX = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX,
+ eMemoryFdPropertiesKHX = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX,
+ eWin32KeyedMutexAcquireReleaseInfoKHX = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX,
+ ePhysicalDeviceExternalSemaphoreInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX,
+ eExternalSemaphorePropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX,
+ eExportSemaphoreCreateInfoKHX = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX,
+ eImportSemaphoreWin32HandleInfoKHX = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX,
+ eExportSemaphoreWin32HandleInfoKHX = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX,
+ eD3D12FenceSubmitInfoKHX = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX,
+ eImportSemaphoreFdInfoKHX = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX,
+ ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
+ eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX,
eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX,
eCmdProcessCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX,
eCmdReserveSpaceForCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX,
eDeviceGeneratedCommandsLimitsNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX,
eDeviceGeneratedCommandsFeaturesNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX,
+ ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT,
eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT,
eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT,
eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT,
- eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT
+ eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
+ ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
+ 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,
+ eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK,
+ eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK
};
struct ApplicationInfo
};
static_assert( sizeof( PhysicalDeviceFeatures2KHR ) == sizeof( VkPhysicalDeviceFeatures2KHR ), "struct and wrapper have different size!" );
- enum class SubpassContents
- {
- eInline = VK_SUBPASS_CONTENTS_INLINE,
- eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
- };
-
- struct PresentInfoKHR
+ struct PhysicalDevicePushDescriptorPropertiesKHR
{
- 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 )
+ PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
+ : sType( StructureType::ePhysicalDevicePushDescriptorPropertiesKHR )
, pNext( nullptr )
- , waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , swapchainCount( swapchainCount_ )
- , pSwapchains( pSwapchains_ )
- , pImageIndices( pImageIndices_ )
- , pResults( pResults_ )
+ , maxPushDescriptors( maxPushDescriptors_ )
{
}
- PresentInfoKHR( VkPresentInfoKHR const & rhs )
+ PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentInfoKHR) );
+ memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) );
}
- PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+ PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentInfoKHR) );
+ memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) );
return *this;
}
- PresentInfoKHR& setPNext( const void* pNext_ )
+ PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ PhysicalDevicePushDescriptorPropertiesKHR& setMaxPushDescriptors( uint32_t maxPushDescriptors_ )
{
- waitSemaphoreCount = waitSemaphoreCount_;
+ maxPushDescriptors = maxPushDescriptors_;
return *this;
}
- PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const
{
- pWaitSemaphores = pWaitSemaphores_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
}
- PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
+ bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
{
- swapchainCount = swapchainCount_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( maxPushDescriptors == rhs.maxPushDescriptors );
}
- PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
+ bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
{
- pSwapchains = pSwapchains_;
- return *this;
+ return !operator==( rhs );
}
- PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
- {
- pImageIndices = pImageIndices_;
- return *this;
- }
+ private:
+ StructureType sType;
- PresentInfoKHR& setPResults( Result* pResults_ )
- {
- pResults = pResults_;
- return *this;
- }
+ public:
+ void* pNext;
+ uint32_t maxPushDescriptors;
+ };
+ static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
- operator const VkPresentInfoKHR&() const
+ struct PhysicalDeviceIDPropertiesKHX
+ {
+ operator const VkPhysicalDeviceIDPropertiesKHX&() const
{
- return *reinterpret_cast<const VkPresentInfoKHR*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceIDPropertiesKHX*>(this);
}
- bool operator==( PresentInfoKHR const& rhs ) const
+ bool operator==( PhysicalDeviceIDPropertiesKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
- && ( pWaitSemaphores == rhs.pWaitSemaphores )
- && ( swapchainCount == rhs.swapchainCount )
- && ( pSwapchains == rhs.pSwapchains )
- && ( pImageIndices == rhs.pImageIndices )
- && ( pResults == rhs.pResults );
+ && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
+ && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
+ && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHX * sizeof( uint8_t ) ) == 0 )
+ && ( deviceLUIDValid == rhs.deviceLUIDValid );
}
- bool operator!=( PresentInfoKHR const& rhs ) const
+ bool operator!=( PhysicalDeviceIDPropertiesKHX const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- const void* pNext;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- uint32_t swapchainCount;
- const SwapchainKHR* pSwapchains;
- const uint32_t* pImageIndices;
- Result* pResults;
- };
- static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
-
- enum class DynamicState
- {
- eViewport = VK_DYNAMIC_STATE_VIEWPORT,
- eScissor = VK_DYNAMIC_STATE_SCISSOR,
- eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
- eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
- eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
- eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
- eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
- eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
- eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE
+ void* pNext;
+ uint8_t deviceUUID[VK_UUID_SIZE];
+ uint8_t driverUUID[VK_UUID_SIZE];
+ uint8_t deviceLUID[VK_LUID_SIZE_KHX];
+ Bool32 deviceLUIDValid;
};
+ static_assert( sizeof( PhysicalDeviceIDPropertiesKHX ) == sizeof( VkPhysicalDeviceIDPropertiesKHX ), "struct and wrapper have different size!" );
- struct PipelineDynamicStateCreateInfo
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct ExportMemoryWin32HandleInfoKHX
{
- PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr )
- : sType( StructureType::ePipelineDynamicStateCreateInfo )
+ ExportMemoryWin32HandleInfoKHX( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
+ : sType( StructureType::eExportMemoryWin32HandleInfoKHX )
, pNext( nullptr )
- , flags( flags_ )
- , dynamicStateCount( dynamicStateCount_ )
- , pDynamicStates( pDynamicStates_ )
+ , pAttributes( pAttributes_ )
+ , dwAccess( dwAccess_ )
+ , name( name_ )
{
}
- PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
+ ExportMemoryWin32HandleInfoKHX( VkExportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
+ memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) );
}
- PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
+ ExportMemoryWin32HandleInfoKHX& operator=( VkExportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
+ memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) );
return *this;
}
- PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
+ ExportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
+ ExportMemoryWin32HandleInfoKHX& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
{
- flags = flags_;
+ pAttributes = pAttributes_;
return *this;
}
- PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
+ ExportMemoryWin32HandleInfoKHX& setDwAccess( DWORD dwAccess_ )
{
- dynamicStateCount = dynamicStateCount_;
+ dwAccess = dwAccess_;
return *this;
}
- PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
+ ExportMemoryWin32HandleInfoKHX& setName( LPCWSTR name_ )
{
- pDynamicStates = pDynamicStates_;
+ name = name_;
return *this;
}
- operator const VkPipelineDynamicStateCreateInfo&() const
+ operator const VkExportMemoryWin32HandleInfoKHX&() const
{
- return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
+ return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHX*>(this);
}
- bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
+ bool operator==( ExportMemoryWin32HandleInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( dynamicStateCount == rhs.dynamicStateCount )
- && ( pDynamicStates == rhs.pDynamicStates );
+ && ( pAttributes == rhs.pAttributes )
+ && ( dwAccess == rhs.dwAccess )
+ && ( name == rhs.name );
}
- bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
+ bool operator!=( ExportMemoryWin32HandleInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineDynamicStateCreateFlags flags;
- uint32_t dynamicStateCount;
- const DynamicState* pDynamicStates;
- };
- static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
-
- enum class QueueFlagBits
- {
- eGraphics = VK_QUEUE_GRAPHICS_BIT,
- eCompute = VK_QUEUE_COMPUTE_BIT,
- eTransfer = VK_QUEUE_TRANSFER_BIT,
- eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT
- };
-
- using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
-
- VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
- {
- return QueueFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
- {
- return ~( QueueFlags( bits ) );
- }
-
- template <> struct FlagTraits<QueueFlagBits>
- {
- enum
- {
- allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding)
- };
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
};
+ static_assert( sizeof( ExportMemoryWin32HandleInfoKHX ) == sizeof( VkExportMemoryWin32HandleInfoKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct QueueFamilyProperties
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct MemoryWin32HandlePropertiesKHX
{
- operator const VkQueueFamilyProperties&() const
+ operator const VkMemoryWin32HandlePropertiesKHX&() const
{
- return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
+ return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHX*>(this);
}
- bool operator==( QueueFamilyProperties const& rhs ) const
+ bool operator==( MemoryWin32HandlePropertiesKHX const& rhs ) const
{
- return ( queueFlags == rhs.queueFlags )
- && ( queueCount == rhs.queueCount )
- && ( timestampValidBits == rhs.timestampValidBits )
- && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memoryTypeBits == rhs.memoryTypeBits );
}
- bool operator!=( QueueFamilyProperties const& rhs ) const
+ bool operator!=( MemoryWin32HandlePropertiesKHX const& rhs ) const
{
return !operator==( rhs );
}
- QueueFlags queueFlags;
- uint32_t queueCount;
- uint32_t timestampValidBits;
- Extent3D minImageTransferGranularity;
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ uint32_t memoryTypeBits;
};
- static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryWin32HandlePropertiesKHX ) == sizeof( VkMemoryWin32HandlePropertiesKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct QueueFamilyProperties2KHR
+ struct MemoryFdPropertiesKHX
{
- operator const VkQueueFamilyProperties2KHR&() const
+ operator const VkMemoryFdPropertiesKHX&() const
{
- return *reinterpret_cast<const VkQueueFamilyProperties2KHR*>(this);
+ return *reinterpret_cast<const VkMemoryFdPropertiesKHX*>(this);
}
- bool operator==( QueueFamilyProperties2KHR const& rhs ) const
+ bool operator==( MemoryFdPropertiesKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( queueFamilyProperties == rhs.queueFamilyProperties );
+ && ( memoryTypeBits == rhs.memoryTypeBits );
}
- bool operator!=( QueueFamilyProperties2KHR const& rhs ) const
+ bool operator!=( MemoryFdPropertiesKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
void* pNext;
- QueueFamilyProperties queueFamilyProperties;
- };
- static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" );
-
- enum class MemoryPropertyFlagBits
- {
- eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
- eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
- eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
- eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
+ uint32_t memoryTypeBits;
};
+ static_assert( sizeof( MemoryFdPropertiesKHX ) == sizeof( VkMemoryFdPropertiesKHX ), "struct and wrapper have different size!" );
- using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
-
- VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
- {
- return MemoryPropertyFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct Win32KeyedMutexAcquireReleaseInfoKHX
{
- return ~( MemoryPropertyFlags( bits ) );
- }
+ Win32KeyedMutexAcquireReleaseInfoKHX( 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::eWin32KeyedMutexAcquireReleaseInfoKHX )
+ , pNext( nullptr )
+ , acquireCount( acquireCount_ )
+ , pAcquireSyncs( pAcquireSyncs_ )
+ , pAcquireKeys( pAcquireKeys_ )
+ , pAcquireTimeouts( pAcquireTimeouts_ )
+ , releaseCount( releaseCount_ )
+ , pReleaseSyncs( pReleaseSyncs_ )
+ , pReleaseKeys( pReleaseKeys_ )
+ {
+ }
- template <> struct FlagTraits<MemoryPropertyFlagBits>
- {
- enum
+ Win32KeyedMutexAcquireReleaseInfoKHX( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs )
{
- allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated)
- };
- };
+ memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) );
+ }
- struct MemoryType
- {
- operator const VkMemoryType&() const
+ Win32KeyedMutexAcquireReleaseInfoKHX& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs )
{
- return *reinterpret_cast<const VkMemoryType*>(this);
+ memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) );
+ return *this;
}
- bool operator==( MemoryType const& rhs ) const
+ Win32KeyedMutexAcquireReleaseInfoKHX& setPNext( const void* pNext_ )
{
- return ( propertyFlags == rhs.propertyFlags )
- && ( heapIndex == rhs.heapIndex );
+ pNext = pNext_;
+ return *this;
}
- bool operator!=( MemoryType const& rhs ) const
+ Win32KeyedMutexAcquireReleaseInfoKHX& setAcquireCount( uint32_t acquireCount_ )
{
- return !operator==( rhs );
+ acquireCount = acquireCount_;
+ return *this;
}
- MemoryPropertyFlags propertyFlags;
- uint32_t heapIndex;
- };
- static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
+ Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+ {
+ pAcquireSyncs = pAcquireSyncs_;
+ return *this;
+ }
- enum class MemoryHeapFlagBits
- {
- eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
- };
+ Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
+ {
+ pAcquireKeys = pAcquireKeys_;
+ return *this;
+ }
- using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
+ Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ )
+ {
+ pAcquireTimeouts = pAcquireTimeouts_;
+ return *this;
+ }
- VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
- {
- return MemoryHeapFlags( bit0 ) | bit1;
- }
+ Win32KeyedMutexAcquireReleaseInfoKHX& setReleaseCount( uint32_t releaseCount_ )
+ {
+ releaseCount = releaseCount_;
+ return *this;
+ }
- VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
- {
- return ~( MemoryHeapFlags( bits ) );
- }
+ Win32KeyedMutexAcquireReleaseInfoKHX& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+ {
+ pReleaseSyncs = pReleaseSyncs_;
+ return *this;
+ }
- template <> struct FlagTraits<MemoryHeapFlagBits>
- {
- enum
+ Win32KeyedMutexAcquireReleaseInfoKHX& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
{
- allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal)
- };
- };
+ pReleaseKeys = pReleaseKeys_;
+ return *this;
+ }
- struct MemoryHeap
- {
- operator const VkMemoryHeap&() const
+ operator const VkWin32KeyedMutexAcquireReleaseInfoKHX&() const
{
- return *reinterpret_cast<const VkMemoryHeap*>(this);
+ return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHX*>(this);
}
- bool operator==( MemoryHeap const& rhs ) const
+ bool operator==( Win32KeyedMutexAcquireReleaseInfoKHX const& rhs ) const
{
- return ( size == rhs.size )
- && ( flags == rhs.flags );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( acquireCount == rhs.acquireCount )
+ && ( pAcquireSyncs == rhs.pAcquireSyncs )
+ && ( pAcquireKeys == rhs.pAcquireKeys )
+ && ( pAcquireTimeouts == rhs.pAcquireTimeouts )
+ && ( releaseCount == rhs.releaseCount )
+ && ( pReleaseSyncs == rhs.pReleaseSyncs )
+ && ( pReleaseKeys == rhs.pReleaseKeys );
}
- bool operator!=( MemoryHeap const& rhs ) const
+ bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
- DeviceSize size;
- MemoryHeapFlags flags;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t acquireCount;
+ const DeviceMemory* pAcquireSyncs;
+ const uint64_t* pAcquireKeys;
+ const uint32_t* pAcquireTimeouts;
+ uint32_t releaseCount;
+ const DeviceMemory* pReleaseSyncs;
+ const uint64_t* pReleaseKeys;
};
- static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
+ static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct PhysicalDeviceMemoryProperties
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ struct ExportSemaphoreWin32HandleInfoKHX
{
- operator const VkPhysicalDeviceMemoryProperties&() const
+ ExportSemaphoreWin32HandleInfoKHX( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
+ : sType( StructureType::eExportSemaphoreWin32HandleInfoKHX )
+ , pNext( nullptr )
+ , pAttributes( pAttributes_ )
+ , dwAccess( dwAccess_ )
+ , name( name_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
}
- bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
+ ExportSemaphoreWin32HandleInfoKHX( VkExportSemaphoreWin32HandleInfoKHX const & rhs )
{
- return ( memoryTypeCount == rhs.memoryTypeCount )
- && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
- && ( memoryHeapCount == rhs.memoryHeapCount )
- && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
+ memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) );
}
- bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
+ ExportSemaphoreWin32HandleInfoKHX& operator=( VkExportSemaphoreWin32HandleInfoKHX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) );
+ return *this;
}
- uint32_t memoryTypeCount;
- MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
- uint32_t memoryHeapCount;
- MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
- };
- static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
+ ExportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- struct PhysicalDeviceMemoryProperties2KHR
- {
- operator const VkPhysicalDeviceMemoryProperties2KHR&() const
+ ExportSemaphoreWin32HandleInfoKHX& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2KHR*>(this);
+ pAttributes = pAttributes_;
+ return *this;
}
- bool operator==( PhysicalDeviceMemoryProperties2KHR const& rhs ) const
+ ExportSemaphoreWin32HandleInfoKHX& setDwAccess( DWORD dwAccess_ )
+ {
+ dwAccess = dwAccess_;
+ return *this;
+ }
+
+ ExportSemaphoreWin32HandleInfoKHX& setName( LPCWSTR name_ )
+ {
+ name = name_;
+ return *this;
+ }
+
+ operator const VkExportSemaphoreWin32HandleInfoKHX&() const
+ {
+ return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHX*>(this);
+ }
+
+ bool operator==( ExportSemaphoreWin32HandleInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memoryProperties == rhs.memoryProperties );
+ && ( pAttributes == rhs.pAttributes )
+ && ( dwAccess == rhs.dwAccess )
+ && ( name == rhs.name );
}
- bool operator!=( PhysicalDeviceMemoryProperties2KHR const& rhs ) const
+ bool operator!=( ExportSemaphoreWin32HandleInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- void* pNext;
- PhysicalDeviceMemoryProperties memoryProperties;
- };
- static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" );
-
- enum class AccessFlagBits
- {
- eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
- eIndexRead = VK_ACCESS_INDEX_READ_BIT,
- eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
- eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
- eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
- eShaderRead = VK_ACCESS_SHADER_READ_BIT,
- eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
- eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
- eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
- eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
- eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
- eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
- eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
- eHostRead = VK_ACCESS_HOST_READ_BIT,
- eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
- eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
- eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
- eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
- eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
};
+ static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHX ) == sizeof( VkExportSemaphoreWin32HandleInfoKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
- using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
-
- VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
- {
- return AccessFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ struct D3D12FenceSubmitInfoKHX
{
- return ~( AccessFlags( bits ) );
- }
+ D3D12FenceSubmitInfoKHX( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr )
+ : sType( StructureType::eD3D12FenceSubmitInfoKHX )
+ , pNext( nullptr )
+ , waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+ , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+ , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
+ , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+ {
+ }
- template <> struct FlagTraits<AccessFlagBits>
- {
- enum
+ D3D12FenceSubmitInfoKHX( VkD3D12FenceSubmitInfoKHX const & rhs )
{
- allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX)
- };
- };
+ memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) );
+ }
- struct MemoryBarrier
- {
- MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() )
- : sType( StructureType::eMemoryBarrier )
- , pNext( nullptr )
- , srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
+ D3D12FenceSubmitInfoKHX& operator=( VkD3D12FenceSubmitInfoKHX const & rhs )
{
+ memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) );
+ return *this;
}
- MemoryBarrier( VkMemoryBarrier const & rhs )
+ D3D12FenceSubmitInfoKHX& setPNext( const void* pNext_ )
{
- memcpy( this, &rhs, sizeof(MemoryBarrier) );
+ pNext = pNext_;
+ return *this;
}
- MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
+ D3D12FenceSubmitInfoKHX& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ )
{
- memcpy( this, &rhs, sizeof(MemoryBarrier) );
+ waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
return *this;
}
- MemoryBarrier& setPNext( const void* pNext_ )
+ D3D12FenceSubmitInfoKHX& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ )
{
- pNext = pNext_;
+ pWaitSemaphoreValues = pWaitSemaphoreValues_;
return *this;
}
- MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ D3D12FenceSubmitInfoKHX& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ )
{
- srcAccessMask = srcAccessMask_;
+ signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
return *this;
}
- MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ D3D12FenceSubmitInfoKHX& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ )
{
- dstAccessMask = dstAccessMask_;
+ pSignalSemaphoreValues = pSignalSemaphoreValues_;
return *this;
}
- operator const VkMemoryBarrier&() const
+ operator const VkD3D12FenceSubmitInfoKHX&() const
{
- return *reinterpret_cast<const VkMemoryBarrier*>(this);
+ return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHX*>(this);
}
- bool operator==( MemoryBarrier const& rhs ) const
+ bool operator==( D3D12FenceSubmitInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask );
+ && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount )
+ && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues )
+ && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount )
+ && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
}
- bool operator!=( MemoryBarrier const& rhs ) const
+ bool operator!=( D3D12FenceSubmitInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
+ uint32_t waitSemaphoreValuesCount;
+ const uint64_t* pWaitSemaphoreValues;
+ uint32_t signalSemaphoreValuesCount;
+ const uint64_t* pSignalSemaphoreValues;
};
- static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
+ static_assert( sizeof( D3D12FenceSubmitInfoKHX ) == sizeof( VkD3D12FenceSubmitInfoKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
- struct BufferMemoryBarrier
+ struct PhysicalDeviceMultiviewFeaturesKHX
{
- 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 )
+ PhysicalDeviceMultiviewFeaturesKHX( Bool32 multiview_ = 0, Bool32 multiviewGeometryShader_ = 0, Bool32 multiviewTessellationShader_ = 0 )
+ : sType( StructureType::ePhysicalDeviceMultiviewFeaturesKHX )
, pNext( nullptr )
- , srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
- , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
- , buffer( buffer_ )
- , offset( offset_ )
- , size( size_ )
+ , multiview( multiview_ )
+ , multiviewGeometryShader( multiviewGeometryShader_ )
+ , multiviewTessellationShader( multiviewTessellationShader_ )
{
}
- BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
+ PhysicalDeviceMultiviewFeaturesKHX( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) );
}
- BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
+ PhysicalDeviceMultiviewFeaturesKHX& operator=( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) );
return *this;
}
- BufferMemoryBarrier& setPNext( const void* pNext_ )
+ PhysicalDeviceMultiviewFeaturesKHX& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ PhysicalDeviceMultiviewFeaturesKHX& setMultiview( Bool32 multiview_ )
{
- srcAccessMask = srcAccessMask_;
+ multiview = multiview_;
return *this;
}
- BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ PhysicalDeviceMultiviewFeaturesKHX& setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ )
{
- dstAccessMask = dstAccessMask_;
+ multiviewGeometryShader = multiviewGeometryShader_;
return *this;
}
- BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+ PhysicalDeviceMultiviewFeaturesKHX& setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ )
{
- srcQueueFamilyIndex = srcQueueFamilyIndex_;
+ multiviewTessellationShader = multiviewTessellationShader_;
return *this;
}
- BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+ operator const VkPhysicalDeviceMultiviewFeaturesKHX&() const
{
- dstQueueFamilyIndex = dstQueueFamilyIndex_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeaturesKHX*>(this);
}
- BufferMemoryBarrier& setBuffer( Buffer buffer_ )
+ bool operator==( PhysicalDeviceMultiviewFeaturesKHX const& rhs ) const
{
- buffer = buffer_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( multiview == rhs.multiview )
+ && ( multiviewGeometryShader == rhs.multiviewGeometryShader )
+ && ( multiviewTessellationShader == rhs.multiviewTessellationShader );
}
- BufferMemoryBarrier& setOffset( DeviceSize offset_ )
+ bool operator!=( PhysicalDeviceMultiviewFeaturesKHX const& rhs ) const
{
- offset = offset_;
- return *this;
+ return !operator==( rhs );
}
- BufferMemoryBarrier& setSize( DeviceSize size_ )
- {
- size = size_;
- return *this;
- }
+ private:
+ StructureType sType;
- operator const VkBufferMemoryBarrier&() const
+ public:
+ void* pNext;
+ Bool32 multiview;
+ Bool32 multiviewGeometryShader;
+ Bool32 multiviewTessellationShader;
+ };
+ static_assert( sizeof( PhysicalDeviceMultiviewFeaturesKHX ) == sizeof( VkPhysicalDeviceMultiviewFeaturesKHX ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceMultiviewPropertiesKHX
+ {
+ operator const VkPhysicalDeviceMultiviewPropertiesKHX&() const
{
- return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceMultiviewPropertiesKHX*>(this);
}
- bool operator==( BufferMemoryBarrier const& rhs ) const
+ bool operator==( PhysicalDeviceMultiviewPropertiesKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
- && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
- && ( buffer == rhs.buffer )
- && ( offset == rhs.offset )
- && ( size == rhs.size );
+ && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount )
+ && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
}
- bool operator!=( BufferMemoryBarrier const& rhs ) const
+ bool operator!=( PhysicalDeviceMultiviewPropertiesKHX const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- const void* pNext;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- Buffer buffer;
- DeviceSize offset;
- DeviceSize size;
- };
- static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
-
- enum class BufferUsageFlagBits
- {
- eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
- eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
- eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
- eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
- eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
- eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
- eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
- eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
- eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
- };
-
- using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
-
- VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
- {
- return BufferUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
- {
- return ~( BufferUsageFlags( bits ) );
- }
-
- template <> struct FlagTraits<BufferUsageFlagBits>
- {
- enum
- {
- allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer)
- };
- };
-
- enum class BufferCreateFlagBits
- {
- eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
- eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
- eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
- };
-
- using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
-
- VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
- {
- return BufferCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
- {
- return ~( BufferCreateFlags( bits ) );
- }
-
- template <> struct FlagTraits<BufferCreateFlagBits>
- {
- enum
- {
- allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased)
- };
+ void* pNext;
+ uint32_t maxMultiviewViewCount;
+ uint32_t maxMultiviewInstanceIndex;
};
+ static_assert( sizeof( PhysicalDeviceMultiviewPropertiesKHX ) == sizeof( VkPhysicalDeviceMultiviewPropertiesKHX ), "struct and wrapper have different size!" );
- struct BufferCreateInfo
+ struct RenderPassMultiviewCreateInfoKHX
{
- 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 )
+ 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 )
- , flags( flags_ )
- , size( size_ )
- , usage( usage_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , subpassCount( subpassCount_ )
+ , pViewMasks( pViewMasks_ )
+ , dependencyCount( dependencyCount_ )
+ , pViewOffsets( pViewOffsets_ )
+ , correlationMaskCount( correlationMaskCount_ )
+ , pCorrelationMasks( pCorrelationMasks_ )
{
}
- BufferCreateInfo( VkBufferCreateInfo const & rhs )
+ RenderPassMultiviewCreateInfoKHX( VkRenderPassMultiviewCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferCreateInfo) );
+ memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) );
}
- BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
+ RenderPassMultiviewCreateInfoKHX& operator=( VkRenderPassMultiviewCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferCreateInfo) );
+ memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) );
return *this;
}
- BufferCreateInfo& setPNext( const void* pNext_ )
+ RenderPassMultiviewCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
+ RenderPassMultiviewCreateInfoKHX& setSubpassCount( uint32_t subpassCount_ )
{
- flags = flags_;
+ subpassCount = subpassCount_;
return *this;
}
- BufferCreateInfo& setSize( DeviceSize size_ )
+ RenderPassMultiviewCreateInfoKHX& setPViewMasks( const uint32_t* pViewMasks_ )
{
- size = size_;
+ pViewMasks = pViewMasks_;
return *this;
}
- BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
+ RenderPassMultiviewCreateInfoKHX& setDependencyCount( uint32_t dependencyCount_ )
{
- usage = usage_;
+ dependencyCount = dependencyCount_;
return *this;
}
- BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
+ RenderPassMultiviewCreateInfoKHX& setPViewOffsets( const int32_t* pViewOffsets_ )
{
- sharingMode = sharingMode_;
+ pViewOffsets = pViewOffsets_;
return *this;
}
- BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ RenderPassMultiviewCreateInfoKHX& setCorrelationMaskCount( uint32_t correlationMaskCount_ )
{
- queueFamilyIndexCount = queueFamilyIndexCount_;
+ correlationMaskCount = correlationMaskCount_;
return *this;
}
- BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ RenderPassMultiviewCreateInfoKHX& setPCorrelationMasks( const uint32_t* pCorrelationMasks_ )
{
- pQueueFamilyIndices = pQueueFamilyIndices_;
+ pCorrelationMasks = pCorrelationMasks_;
return *this;
}
- operator const VkBufferCreateInfo&() const
+ operator const VkRenderPassMultiviewCreateInfoKHX&() const
{
- return *reinterpret_cast<const VkBufferCreateInfo*>(this);
+ return *reinterpret_cast<const VkRenderPassMultiviewCreateInfoKHX*>(this);
}
- bool operator==( BufferCreateInfo const& rhs ) const
+ bool operator==( RenderPassMultiviewCreateInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( size == rhs.size )
- && ( usage == rhs.usage )
- && ( sharingMode == rhs.sharingMode )
- && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
- && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+ && ( subpassCount == rhs.subpassCount )
+ && ( pViewMasks == rhs.pViewMasks )
+ && ( dependencyCount == rhs.dependencyCount )
+ && ( pViewOffsets == rhs.pViewOffsets )
+ && ( correlationMaskCount == rhs.correlationMaskCount )
+ && ( pCorrelationMasks == rhs.pCorrelationMasks );
}
- bool operator!=( BufferCreateInfo const& rhs ) const
+ bool operator!=( RenderPassMultiviewCreateInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- BufferCreateFlags flags;
- DeviceSize size;
- BufferUsageFlags usage;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- };
- static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
-
- enum class ShaderStageFlagBits
- {
- eVertex = VK_SHADER_STAGE_VERTEX_BIT,
- eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
- eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
- eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
- eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
- eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
- eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
- eAll = VK_SHADER_STAGE_ALL
+ uint32_t subpassCount;
+ const uint32_t* pViewMasks;
+ uint32_t dependencyCount;
+ const int32_t* pViewOffsets;
+ uint32_t correlationMaskCount;
+ const uint32_t* pCorrelationMasks;
};
+ static_assert( sizeof( RenderPassMultiviewCreateInfoKHX ) == sizeof( VkRenderPassMultiviewCreateInfoKHX ), "struct and wrapper have different size!" );
- using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
-
- VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
- {
- return ShaderStageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
- {
- return ~( ShaderStageFlags( bits ) );
- }
-
- template <> struct FlagTraits<ShaderStageFlagBits>
+ struct BindBufferMemoryInfoKHX
{
- enum
+ BindBufferMemoryInfoKHX( Buffer buffer_ = Buffer(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr )
+ : sType( StructureType::eBindBufferMemoryInfoKHX )
+ , pNext( nullptr )
+ , buffer( buffer_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , deviceIndexCount( deviceIndexCount_ )
+ , pDeviceIndices( pDeviceIndices_ )
{
- allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll)
- };
- };
+ }
- struct DescriptorSetLayoutBinding
- {
- DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr )
- : binding( binding_ )
- , descriptorType( descriptorType_ )
- , descriptorCount( descriptorCount_ )
- , stageFlags( stageFlags_ )
- , pImmutableSamplers( pImmutableSamplers_ )
+ BindBufferMemoryInfoKHX( VkBindBufferMemoryInfoKHX const & rhs )
{
+ memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) );
}
- DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
+ BindBufferMemoryInfoKHX& operator=( VkBindBufferMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
+ memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) );
+ return *this;
}
- DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
+ BindBufferMemoryInfoKHX& setPNext( const void* pNext_ )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
+ pNext = pNext_;
return *this;
}
- DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
+ BindBufferMemoryInfoKHX& setBuffer( Buffer buffer_ )
{
- binding = binding_;
+ buffer = buffer_;
return *this;
}
- DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
+ BindBufferMemoryInfoKHX& setMemory( DeviceMemory memory_ )
{
- descriptorType = descriptorType_;
+ memory = memory_;
return *this;
}
- DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
+ BindBufferMemoryInfoKHX& setMemoryOffset( DeviceSize memoryOffset_ )
{
- descriptorCount = descriptorCount_;
+ memoryOffset = memoryOffset_;
return *this;
}
- DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
+ BindBufferMemoryInfoKHX& setDeviceIndexCount( uint32_t deviceIndexCount_ )
{
- stageFlags = stageFlags_;
+ deviceIndexCount = deviceIndexCount_;
return *this;
}
- DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
+ BindBufferMemoryInfoKHX& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
{
- pImmutableSamplers = pImmutableSamplers_;
+ pDeviceIndices = pDeviceIndices_;
return *this;
}
- operator const VkDescriptorSetLayoutBinding&() const
+ operator const VkBindBufferMemoryInfoKHX&() const
{
- return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
+ return *reinterpret_cast<const VkBindBufferMemoryInfoKHX*>(this);
}
- bool operator==( DescriptorSetLayoutBinding const& rhs ) const
+ bool operator==( BindBufferMemoryInfoKHX const& rhs ) const
{
- return ( binding == rhs.binding )
- && ( descriptorType == rhs.descriptorType )
- && ( descriptorCount == rhs.descriptorCount )
- && ( stageFlags == rhs.stageFlags )
- && ( pImmutableSamplers == rhs.pImmutableSamplers );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( buffer == rhs.buffer )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( deviceIndexCount == rhs.deviceIndexCount )
+ && ( pDeviceIndices == rhs.pDeviceIndices );
}
- bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
+ bool operator!=( BindBufferMemoryInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t binding;
- DescriptorType descriptorType;
- uint32_t descriptorCount;
- ShaderStageFlags stageFlags;
- const Sampler* pImmutableSamplers;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ Buffer buffer;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
};
- static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
+ static_assert( sizeof( BindBufferMemoryInfoKHX ) == sizeof( VkBindBufferMemoryInfoKHX ), "struct and wrapper have different size!" );
- struct DescriptorSetLayoutCreateInfo
+ struct BindImageMemoryInfoKHX
{
- DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr )
- : sType( StructureType::eDescriptorSetLayoutCreateInfo )
+ BindImageMemoryInfoKHX( Image image_ = Image(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t SFRRectCount_ = 0, const Rect2D* pSFRRects_ = nullptr )
+ : sType( StructureType::eBindImageMemoryInfoKHX )
, pNext( nullptr )
- , flags( flags_ )
- , bindingCount( bindingCount_ )
- , pBindings( pBindings_ )
+ , image( image_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , deviceIndexCount( deviceIndexCount_ )
+ , pDeviceIndices( pDeviceIndices_ )
+ , SFRRectCount( SFRRectCount_ )
+ , pSFRRects( pSFRRects_ )
{
}
- DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
+ BindImageMemoryInfoKHX( VkBindImageMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) );
}
- DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
+ BindImageMemoryInfoKHX& operator=( VkBindImageMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) );
return *this;
}
- DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
+ BindImageMemoryInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
+ BindImageMemoryInfoKHX& setImage( Image image_ )
{
- flags = flags_;
+ image = image_;
return *this;
}
- DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
+ BindImageMemoryInfoKHX& setMemory( DeviceMemory memory_ )
{
- bindingCount = bindingCount_;
+ memory = memory_;
return *this;
}
- DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
+ BindImageMemoryInfoKHX& setMemoryOffset( DeviceSize memoryOffset_ )
{
- pBindings = pBindings_;
+ memoryOffset = memoryOffset_;
return *this;
}
- operator const VkDescriptorSetLayoutCreateInfo&() const
+ BindImageMemoryInfoKHX& setDeviceIndexCount( uint32_t deviceIndexCount_ )
{
- return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
+ deviceIndexCount = deviceIndexCount_;
+ return *this;
}
- bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
+ BindImageMemoryInfoKHX& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
+ {
+ pDeviceIndices = pDeviceIndices_;
+ return *this;
+ }
+
+ BindImageMemoryInfoKHX& setSFRRectCount( uint32_t SFRRectCount_ )
+ {
+ SFRRectCount = SFRRectCount_;
+ return *this;
+ }
+
+ BindImageMemoryInfoKHX& setPSFRRects( const Rect2D* pSFRRects_ )
+ {
+ pSFRRects = pSFRRects_;
+ return *this;
+ }
+
+ operator const VkBindImageMemoryInfoKHX&() const
+ {
+ return *reinterpret_cast<const VkBindImageMemoryInfoKHX*>(this);
+ }
+
+ bool operator==( BindImageMemoryInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( bindingCount == rhs.bindingCount )
- && ( pBindings == rhs.pBindings );
+ && ( image == rhs.image )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( deviceIndexCount == rhs.deviceIndexCount )
+ && ( pDeviceIndices == rhs.pDeviceIndices )
+ && ( SFRRectCount == rhs.SFRRectCount )
+ && ( pSFRRects == rhs.pSFRRects );
}
- bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
+ bool operator!=( BindImageMemoryInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- DescriptorSetLayoutCreateFlags flags;
- uint32_t bindingCount;
- const DescriptorSetLayoutBinding* pBindings;
+ Image image;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
+ uint32_t SFRRectCount;
+ const Rect2D* pSFRRects;
};
- static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( BindImageMemoryInfoKHX ) == sizeof( VkBindImageMemoryInfoKHX ), "struct and wrapper have different size!" );
- struct PipelineShaderStageCreateInfo
+ struct DeviceGroupRenderPassBeginInfoKHX
{
- PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr )
- : sType( StructureType::ePipelineShaderStageCreateInfo )
+ DeviceGroupRenderPassBeginInfoKHX( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const Rect2D* pDeviceRenderAreas_ = nullptr )
+ : sType( StructureType::eDeviceGroupRenderPassBeginInfoKHX )
, pNext( nullptr )
- , flags( flags_ )
- , stage( stage_ )
- , module( module_ )
- , pName( pName_ )
- , pSpecializationInfo( pSpecializationInfo_ )
+ , deviceMask( deviceMask_ )
+ , deviceRenderAreaCount( deviceRenderAreaCount_ )
+ , pDeviceRenderAreas( pDeviceRenderAreas_ )
{
}
- PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
+ DeviceGroupRenderPassBeginInfoKHX( VkDeviceGroupRenderPassBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
+ memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) );
}
- PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
+ DeviceGroupRenderPassBeginInfoKHX& operator=( VkDeviceGroupRenderPassBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
+ memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) );
return *this;
}
- PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
+ DeviceGroupRenderPassBeginInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
- {
- stage = stage_;
- return *this;
- }
-
- PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
+ DeviceGroupRenderPassBeginInfoKHX& setDeviceMask( uint32_t deviceMask_ )
{
- module = module_;
+ deviceMask = deviceMask_;
return *this;
}
- PipelineShaderStageCreateInfo& setPName( const char* pName_ )
+ DeviceGroupRenderPassBeginInfoKHX& setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ )
{
- pName = pName_;
+ deviceRenderAreaCount = deviceRenderAreaCount_;
return *this;
}
- PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
+ DeviceGroupRenderPassBeginInfoKHX& setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ )
{
- pSpecializationInfo = pSpecializationInfo_;
+ pDeviceRenderAreas = pDeviceRenderAreas_;
return *this;
}
- operator const VkPipelineShaderStageCreateInfo&() const
+ operator const VkDeviceGroupRenderPassBeginInfoKHX&() const
{
- return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
+ return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfoKHX*>(this);
}
- bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
+ bool operator==( DeviceGroupRenderPassBeginInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( stage == rhs.stage )
- && ( module == rhs.module )
- && ( pName == rhs.pName )
- && ( pSpecializationInfo == rhs.pSpecializationInfo );
+ && ( deviceMask == rhs.deviceMask )
+ && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount )
+ && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
}
- bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
+ bool operator!=( DeviceGroupRenderPassBeginInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineShaderStageCreateFlags flags;
- ShaderStageFlagBits stage;
- ShaderModule module;
- const char* pName;
- const SpecializationInfo* pSpecializationInfo;
+ uint32_t deviceMask;
+ uint32_t deviceRenderAreaCount;
+ const Rect2D* pDeviceRenderAreas;
};
- static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupRenderPassBeginInfoKHX ) == sizeof( VkDeviceGroupRenderPassBeginInfoKHX ), "struct and wrapper have different size!" );
- struct PushConstantRange
+ struct DeviceGroupCommandBufferBeginInfoKHX
{
- PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 )
- : stageFlags( stageFlags_ )
- , offset( offset_ )
- , size( size_ )
- {
- }
-
- PushConstantRange( VkPushConstantRange const & rhs )
+ DeviceGroupCommandBufferBeginInfoKHX( uint32_t deviceMask_ = 0 )
+ : sType( StructureType::eDeviceGroupCommandBufferBeginInfoKHX )
+ , pNext( nullptr )
+ , deviceMask( deviceMask_ )
{
- memcpy( this, &rhs, sizeof(PushConstantRange) );
}
- PushConstantRange& operator=( VkPushConstantRange const & rhs )
+ DeviceGroupCommandBufferBeginInfoKHX( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PushConstantRange) );
- return *this;
+ memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) );
}
- PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
+ DeviceGroupCommandBufferBeginInfoKHX& operator=( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs )
{
- stageFlags = stageFlags_;
+ memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) );
return *this;
}
- PushConstantRange& setOffset( uint32_t offset_ )
+ DeviceGroupCommandBufferBeginInfoKHX& setPNext( const void* pNext_ )
{
- offset = offset_;
+ pNext = pNext_;
return *this;
}
- PushConstantRange& setSize( uint32_t size_ )
+ DeviceGroupCommandBufferBeginInfoKHX& setDeviceMask( uint32_t deviceMask_ )
{
- size = size_;
+ deviceMask = deviceMask_;
return *this;
}
- operator const VkPushConstantRange&() const
+ operator const VkDeviceGroupCommandBufferBeginInfoKHX&() const
{
- return *reinterpret_cast<const VkPushConstantRange*>(this);
+ return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfoKHX*>(this);
}
- bool operator==( PushConstantRange const& rhs ) const
+ bool operator==( DeviceGroupCommandBufferBeginInfoKHX const& rhs ) const
{
- return ( stageFlags == rhs.stageFlags )
- && ( offset == rhs.offset )
- && ( size == rhs.size );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( deviceMask == rhs.deviceMask );
}
- bool operator!=( PushConstantRange const& rhs ) const
+ bool operator!=( DeviceGroupCommandBufferBeginInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
- ShaderStageFlags stageFlags;
- uint32_t offset;
- uint32_t size;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t deviceMask;
};
- static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupCommandBufferBeginInfoKHX ) == sizeof( VkDeviceGroupCommandBufferBeginInfoKHX ), "struct and wrapper have different size!" );
- struct PipelineLayoutCreateInfo
+ struct DeviceGroupSubmitInfoKHX
{
- PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr )
- : sType( StructureType::ePipelineLayoutCreateInfo )
+ 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 )
- , flags( flags_ )
- , setLayoutCount( setLayoutCount_ )
- , pSetLayouts( pSetLayouts_ )
- , pushConstantRangeCount( pushConstantRangeCount_ )
- , pPushConstantRanges( pPushConstantRanges_ )
+ , waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
+ , commandBufferCount( commandBufferCount_ )
+ , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
+ , signalSemaphoreCount( signalSemaphoreCount_ )
+ , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
{
}
- PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
+ DeviceGroupSubmitInfoKHX( VkDeviceGroupSubmitInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) );
}
- PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
+ DeviceGroupSubmitInfoKHX& operator=( VkDeviceGroupSubmitInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) );
return *this;
}
- PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
+ DeviceGroupSubmitInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
+ DeviceGroupSubmitInfoKHX& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
{
- flags = flags_;
+ waitSemaphoreCount = waitSemaphoreCount_;
return *this;
}
- PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
+ DeviceGroupSubmitInfoKHX& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ )
{
- setLayoutCount = setLayoutCount_;
+ pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_;
return *this;
}
- PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+ DeviceGroupSubmitInfoKHX& setCommandBufferCount( uint32_t commandBufferCount_ )
{
- pSetLayouts = pSetLayouts_;
+ commandBufferCount = commandBufferCount_;
return *this;
}
- PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
+ DeviceGroupSubmitInfoKHX& setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ )
{
- pushConstantRangeCount = pushConstantRangeCount_;
+ pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_;
return *this;
}
- PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+ DeviceGroupSubmitInfoKHX& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
{
- pPushConstantRanges = pPushConstantRanges_;
+ signalSemaphoreCount = signalSemaphoreCount_;
return *this;
}
- operator const VkPipelineLayoutCreateInfo&() const
+ DeviceGroupSubmitInfoKHX& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ )
{
- return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
+ pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_;
+ return *this;
}
- bool operator==( PipelineLayoutCreateInfo const& rhs ) const
+ operator const VkDeviceGroupSubmitInfoKHX&() const
+ {
+ return *reinterpret_cast<const VkDeviceGroupSubmitInfoKHX*>(this);
+ }
+
+ bool operator==( DeviceGroupSubmitInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( setLayoutCount == rhs.setLayoutCount )
- && ( pSetLayouts == rhs.pSetLayouts )
- && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
- && ( pPushConstantRanges == rhs.pPushConstantRanges );
+ && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+ && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices )
+ && ( commandBufferCount == rhs.commandBufferCount )
+ && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks )
+ && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
+ && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
}
- bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
+ bool operator!=( DeviceGroupSubmitInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineLayoutCreateFlags flags;
- uint32_t setLayoutCount;
- const DescriptorSetLayout* pSetLayouts;
- uint32_t pushConstantRangeCount;
- const PushConstantRange* pPushConstantRanges;
- };
- static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
-
- enum class ImageUsageFlagBits
- {
- eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
- eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
- eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
- eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
- eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
- eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
- eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
- eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
- };
-
- using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
-
- VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
- {
- return ImageUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
- {
- return ~( ImageUsageFlags( bits ) );
- }
-
- template <> struct FlagTraits<ImageUsageFlagBits>
- {
- enum
- {
- allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment)
- };
- };
-
- enum class ImageCreateFlagBits
- {
- eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
- eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
- eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
- eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
- eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
- e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR
- };
-
- using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
-
- VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
- {
- return ImageCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
- {
- return ~( ImageCreateFlags( bits ) );
- }
-
- template <> struct FlagTraits<ImageCreateFlagBits>
- {
- enum
- {
- allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::e2DArrayCompatibleKHR)
- };
+ uint32_t waitSemaphoreCount;
+ const uint32_t* pWaitSemaphoreDeviceIndices;
+ uint32_t commandBufferCount;
+ const uint32_t* pCommandBufferDeviceMasks;
+ uint32_t signalSemaphoreCount;
+ const uint32_t* pSignalSemaphoreDeviceIndices;
};
+ static_assert( sizeof( DeviceGroupSubmitInfoKHX ) == sizeof( VkDeviceGroupSubmitInfoKHX ), "struct and wrapper have different size!" );
- struct PhysicalDeviceImageFormatInfo2KHR
+ struct DeviceGroupBindSparseInfoKHX
{
- PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() )
- : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHR )
+ DeviceGroupBindSparseInfoKHX( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 )
+ : sType( StructureType::eDeviceGroupBindSparseInfoKHX )
, pNext( nullptr )
- , format( format_ )
- , type( type_ )
- , tiling( tiling_ )
- , usage( usage_ )
- , flags( flags_ )
+ , resourceDeviceIndex( resourceDeviceIndex_ )
+ , memoryDeviceIndex( memoryDeviceIndex_ )
{
}
- PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
+ DeviceGroupBindSparseInfoKHX( VkDeviceGroupBindSparseInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) );
}
- PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
+ DeviceGroupBindSparseInfoKHX& operator=( VkDeviceGroupBindSparseInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) );
return *this;
}
- PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ )
+ DeviceGroupBindSparseInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceImageFormatInfo2KHR& setFormat( Format format_ )
- {
- format = format_;
- return *this;
- }
-
- PhysicalDeviceImageFormatInfo2KHR& setType( ImageType type_ )
- {
- type = type_;
- return *this;
- }
-
- PhysicalDeviceImageFormatInfo2KHR& setTiling( ImageTiling tiling_ )
- {
- tiling = tiling_;
- return *this;
- }
-
- PhysicalDeviceImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ )
+ DeviceGroupBindSparseInfoKHX& setResourceDeviceIndex( uint32_t resourceDeviceIndex_ )
{
- usage = usage_;
+ resourceDeviceIndex = resourceDeviceIndex_;
return *this;
}
- PhysicalDeviceImageFormatInfo2KHR& setFlags( ImageCreateFlags flags_ )
+ DeviceGroupBindSparseInfoKHX& setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ )
{
- flags = flags_;
+ memoryDeviceIndex = memoryDeviceIndex_;
return *this;
}
- operator const VkPhysicalDeviceImageFormatInfo2KHR&() const
+ operator const VkDeviceGroupBindSparseInfoKHX&() const
{
- return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>(this);
+ return *reinterpret_cast<const VkDeviceGroupBindSparseInfoKHX*>(this);
}
- bool operator==( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const
+ bool operator==( DeviceGroupBindSparseInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( format == rhs.format )
- && ( type == rhs.type )
- && ( tiling == rhs.tiling )
- && ( usage == rhs.usage )
- && ( flags == rhs.flags );
+ && ( resourceDeviceIndex == rhs.resourceDeviceIndex )
+ && ( memoryDeviceIndex == rhs.memoryDeviceIndex );
}
- bool operator!=( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const
+ bool operator!=( DeviceGroupBindSparseInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- Format format;
- ImageType type;
- ImageTiling tiling;
- ImageUsageFlags usage;
- ImageCreateFlags flags;
+ uint32_t resourceDeviceIndex;
+ uint32_t memoryDeviceIndex;
};
- static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupBindSparseInfoKHX ) == sizeof( VkDeviceGroupBindSparseInfoKHX ), "struct and wrapper have different size!" );
- enum class PipelineCreateFlagBits
+ struct ImageSwapchainCreateInfoKHX
{
- eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
- eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
- eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT
- };
+ ImageSwapchainCreateInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR() )
+ : sType( StructureType::eImageSwapchainCreateInfoKHX )
+ , pNext( nullptr )
+ , swapchain( swapchain_ )
+ {
+ }
- using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
+ ImageSwapchainCreateInfoKHX( VkImageSwapchainCreateInfoKHX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) );
+ }
- VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
- {
- return PipelineCreateFlags( bit0 ) | bit1;
- }
+ ImageSwapchainCreateInfoKHX& operator=( VkImageSwapchainCreateInfoKHX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) );
+ return *this;
+ }
- VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
- {
- return ~( PipelineCreateFlags( bits ) );
- }
+ ImageSwapchainCreateInfoKHX& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- template <> struct FlagTraits<PipelineCreateFlagBits>
- {
- enum
+ ImageSwapchainCreateInfoKHX& setSwapchain( SwapchainKHR swapchain_ )
{
- allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative)
- };
- };
+ swapchain = swapchain_;
+ return *this;
+ }
- 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_ )
- , stage( stage_ )
- , layout( layout_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
+ operator const VkImageSwapchainCreateInfoKHX&() const
{
+ return *reinterpret_cast<const VkImageSwapchainCreateInfoKHX*>(this);
}
- ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
+ bool operator==( ImageSwapchainCreateInfoKHX const& rhs ) const
{
- memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( swapchain == rhs.swapchain );
}
- ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
+ bool operator!=( ImageSwapchainCreateInfoKHX const& rhs ) const
{
- memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
- return *this;
+ return !operator==( rhs );
}
- ComputePipelineCreateInfo& setPNext( const void* pNext_ )
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ 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_ )
+ , imageIndex( imageIndex_ )
{
- pNext = pNext_;
- return *this;
}
- ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
+ BindImageMemorySwapchainInfoKHX( VkBindImageMemorySwapchainInfoKHX const & rhs )
{
- flags = flags_;
- return *this;
+ memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) );
}
- ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
+ BindImageMemorySwapchainInfoKHX& operator=( VkBindImageMemorySwapchainInfoKHX const & rhs )
{
- stage = stage_;
+ memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) );
return *this;
}
- ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
+ BindImageMemorySwapchainInfoKHX& setPNext( const void* pNext_ )
{
- layout = layout_;
+ pNext = pNext_;
return *this;
}
- ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ BindImageMemorySwapchainInfoKHX& setSwapchain( SwapchainKHR swapchain_ )
{
- basePipelineHandle = basePipelineHandle_;
+ swapchain = swapchain_;
return *this;
}
- ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
+ BindImageMemorySwapchainInfoKHX& setImageIndex( uint32_t imageIndex_ )
{
- basePipelineIndex = basePipelineIndex_;
+ imageIndex = imageIndex_;
return *this;
}
- operator const VkComputePipelineCreateInfo&() const
+ operator const VkBindImageMemorySwapchainInfoKHX&() const
{
- return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
+ return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHX*>(this);
}
- bool operator==( ComputePipelineCreateInfo const& rhs ) const
+ bool operator==( BindImageMemorySwapchainInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( stage == rhs.stage )
- && ( layout == rhs.layout )
- && ( basePipelineHandle == rhs.basePipelineHandle )
- && ( basePipelineIndex == rhs.basePipelineIndex );
+ && ( swapchain == rhs.swapchain )
+ && ( imageIndex == rhs.imageIndex );
}
- bool operator!=( ComputePipelineCreateInfo const& rhs ) const
+ bool operator!=( BindImageMemorySwapchainInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineCreateFlags flags;
- PipelineShaderStageCreateInfo stage;
- PipelineLayout layout;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
- };
- static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
-
- enum class ColorComponentFlagBits
- {
- eR = VK_COLOR_COMPONENT_R_BIT,
- eG = VK_COLOR_COMPONENT_G_BIT,
- eB = VK_COLOR_COMPONENT_B_BIT,
- eA = VK_COLOR_COMPONENT_A_BIT
- };
-
- using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
-
- VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
- {
- return ColorComponentFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
- {
- return ~( ColorComponentFlags( bits ) );
- }
-
- template <> struct FlagTraits<ColorComponentFlagBits>
- {
- enum
- {
- allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
- };
+ SwapchainKHR swapchain;
+ uint32_t imageIndex;
};
+ static_assert( sizeof( BindImageMemorySwapchainInfoKHX ) == sizeof( VkBindImageMemorySwapchainInfoKHX ), "struct and wrapper have different size!" );
- struct PipelineColorBlendAttachmentState
+ struct AcquireNextImageInfoKHX
{
- PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, BlendOp colorBlendOp_ = BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, BlendOp alphaBlendOp_ = BlendOp::eAdd, ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
- : blendEnable( blendEnable_ )
- , srcColorBlendFactor( srcColorBlendFactor_ )
- , dstColorBlendFactor( dstColorBlendFactor_ )
- , colorBlendOp( colorBlendOp_ )
- , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
- , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
- , alphaBlendOp( alphaBlendOp_ )
- , colorWriteMask( colorWriteMask_ )
- {
- }
-
- PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
- {
- memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
- }
-
- PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
+ 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_ )
+ , timeout( timeout_ )
+ , semaphore( semaphore_ )
+ , fence( fence_ )
+ , deviceMask( deviceMask_ )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
- return *this;
}
- PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
+ AcquireNextImageInfoKHX( VkAcquireNextImageInfoKHX const & rhs )
{
- blendEnable = blendEnable_;
- return *this;
+ memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) );
}
- PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
+ AcquireNextImageInfoKHX& operator=( VkAcquireNextImageInfoKHX const & rhs )
{
- srcColorBlendFactor = srcColorBlendFactor_;
+ memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) );
return *this;
}
- PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
+ AcquireNextImageInfoKHX& setPNext( const void* pNext_ )
{
- dstColorBlendFactor = dstColorBlendFactor_;
+ pNext = pNext_;
return *this;
}
- PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
+ AcquireNextImageInfoKHX& setSwapchain( SwapchainKHR swapchain_ )
{
- colorBlendOp = colorBlendOp_;
+ swapchain = swapchain_;
return *this;
}
- PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
+ AcquireNextImageInfoKHX& setTimeout( uint64_t timeout_ )
{
- srcAlphaBlendFactor = srcAlphaBlendFactor_;
+ timeout = timeout_;
return *this;
}
- PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
+ AcquireNextImageInfoKHX& setSemaphore( Semaphore semaphore_ )
{
- dstAlphaBlendFactor = dstAlphaBlendFactor_;
+ semaphore = semaphore_;
return *this;
}
- PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
+ AcquireNextImageInfoKHX& setFence( Fence fence_ )
{
- alphaBlendOp = alphaBlendOp_;
+ fence = fence_;
return *this;
}
- PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
+ AcquireNextImageInfoKHX& setDeviceMask( uint32_t deviceMask_ )
{
- colorWriteMask = colorWriteMask_;
+ deviceMask = deviceMask_;
return *this;
}
- operator const VkPipelineColorBlendAttachmentState&() const
+ operator const VkAcquireNextImageInfoKHX&() const
{
- return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
+ return *reinterpret_cast<const VkAcquireNextImageInfoKHX*>(this);
}
- bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
+ bool operator==( AcquireNextImageInfoKHX const& rhs ) const
{
- return ( blendEnable == rhs.blendEnable )
- && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
- && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
- && ( colorBlendOp == rhs.colorBlendOp )
- && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
- && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
- && ( alphaBlendOp == rhs.alphaBlendOp )
- && ( colorWriteMask == rhs.colorWriteMask );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( swapchain == rhs.swapchain )
+ && ( timeout == rhs.timeout )
+ && ( semaphore == rhs.semaphore )
+ && ( fence == rhs.fence )
+ && ( deviceMask == rhs.deviceMask );
}
- bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
+ bool operator!=( AcquireNextImageInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
- Bool32 blendEnable;
- BlendFactor srcColorBlendFactor;
- BlendFactor dstColorBlendFactor;
- BlendOp colorBlendOp;
- BlendFactor srcAlphaBlendFactor;
- BlendFactor dstAlphaBlendFactor;
- BlendOp alphaBlendOp;
- ColorComponentFlags colorWriteMask;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ SwapchainKHR swapchain;
+ uint64_t timeout;
+ Semaphore semaphore;
+ Fence fence;
+ uint32_t deviceMask;
};
- static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
+ static_assert( sizeof( AcquireNextImageInfoKHX ) == sizeof( VkAcquireNextImageInfoKHX ), "struct and wrapper have different size!" );
- struct PipelineColorBlendStateCreateInfo
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ struct IOSSurfaceCreateInfoMVK
{
- 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 )
+ IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
+ : sType( StructureType::eIOSSurfaceCreateInfoMVK )
, pNext( nullptr )
, flags( flags_ )
- , logicOpEnable( logicOpEnable_ )
- , logicOp( logicOp_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
+ , pView( pView_ )
{
- memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
}
- PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
+ IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
+ memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) );
}
- PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
+ IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
+ memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) );
return *this;
}
- PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
+ IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
+ IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ )
{
flags = flags_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
+ IOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
{
- logicOpEnable = logicOpEnable_;
+ pView = pView_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
+ operator const VkIOSSurfaceCreateInfoMVK&() const
{
- logicOp = logicOp_;
+ return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this);
+ }
+
+ bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( pView == rhs.pView );
+ }
+
+ bool operator!=( IOSSurfaceCreateInfoMVK const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ IOSSurfaceCreateFlagsMVK flags;
+ const void* pView;
+ };
+ static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ struct MacOSSurfaceCreateInfoMVK
+ {
+ MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
+ : sType( StructureType::eMacOSSurfaceCreateInfoMVK )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , pView( pView_ )
+ {
+ }
+
+ MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) );
+ }
+
+ MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) );
return *this;
}
- PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
+ MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
{
- attachmentCount = attachmentCount_;
+ pNext = pNext_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
+ MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
{
- pAttachments = pAttachments_;
+ flags = flags_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
+ MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
{
- memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
+ pView = pView_;
return *this;
}
- operator const VkPipelineColorBlendStateCreateInfo&() const
+ operator const VkMacOSSurfaceCreateInfoMVK&() const
{
- return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
+ return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this);
}
- bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
+ bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( logicOpEnable == rhs.logicOpEnable )
- && ( logicOp == rhs.logicOp )
- && ( attachmentCount == rhs.attachmentCount )
- && ( pAttachments == rhs.pAttachments )
- && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
+ && ( pView == rhs.pView );
}
- bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
+ bool operator!=( MacOSSurfaceCreateInfoMVK const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineColorBlendStateCreateFlags flags;
- Bool32 logicOpEnable;
- LogicOp logicOp;
- uint32_t attachmentCount;
- const PipelineColorBlendAttachmentState* pAttachments;
- float blendConstants[4];
- };
- static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
-
- enum class FenceCreateFlagBits
- {
- eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
+ MacOSSurfaceCreateFlagsMVK flags;
+ const void* pView;
};
+ static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
- using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
-
- VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
- {
- return FenceCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
+ struct PipelineViewportWScalingStateCreateInfoNV
{
- return ~( FenceCreateFlags( bits ) );
- }
+ PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const ViewportWScalingNV* pViewportWScalings_ = nullptr )
+ : sType( StructureType::ePipelineViewportWScalingStateCreateInfoNV )
+ , pNext( nullptr )
+ , viewportWScalingEnable( viewportWScalingEnable_ )
+ , viewportCount( viewportCount_ )
+ , pViewportWScalings( pViewportWScalings_ )
+ {
+ }
- template <> struct FlagTraits<FenceCreateFlagBits>
- {
- enum
+ PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
{
- allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
- };
- };
+ memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) );
+ }
- struct FenceCreateInfo
- {
- FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
- : sType( StructureType::eFenceCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
{
+ memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) );
+ return *this;
}
- FenceCreateInfo( VkFenceCreateInfo const & rhs )
+ PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ )
{
- memcpy( this, &rhs, sizeof(FenceCreateInfo) );
+ pNext = pNext_;
+ return *this;
}
- FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
+ PipelineViewportWScalingStateCreateInfoNV& setViewportWScalingEnable( Bool32 viewportWScalingEnable_ )
{
- memcpy( this, &rhs, sizeof(FenceCreateInfo) );
+ viewportWScalingEnable = viewportWScalingEnable_;
return *this;
}
- FenceCreateInfo& setPNext( const void* pNext_ )
+ PipelineViewportWScalingStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
{
- pNext = pNext_;
+ viewportCount = viewportCount_;
return *this;
}
- FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
+ PipelineViewportWScalingStateCreateInfoNV& setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ )
{
- flags = flags_;
+ pViewportWScalings = pViewportWScalings_;
return *this;
}
- operator const VkFenceCreateInfo&() const
+ operator const VkPipelineViewportWScalingStateCreateInfoNV&() const
{
- return *reinterpret_cast<const VkFenceCreateInfo*>(this);
+ return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this);
}
- bool operator==( FenceCreateInfo const& rhs ) const
+ bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags );
+ && ( viewportWScalingEnable == rhs.viewportWScalingEnable )
+ && ( viewportCount == rhs.viewportCount )
+ && ( pViewportWScalings == rhs.pViewportWScalings );
}
- bool operator!=( FenceCreateInfo const& rhs ) const
+ bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- FenceCreateFlags flags;
+ Bool32 viewportWScalingEnable;
+ uint32_t viewportCount;
+ const ViewportWScalingNV* pViewportWScalings;
};
- static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
- enum class FormatFeatureFlagBits
+ struct PhysicalDeviceDiscardRectanglePropertiesEXT
{
- eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
- eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
- eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
- eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
- eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
- eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
- eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
- eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
- eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
- eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
- eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
- eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
- eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
- eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
- eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR,
- eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR
- };
+ PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
+ : sType( StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT )
+ , pNext( nullptr )
+ , maxDiscardRectangles( maxDiscardRectangles_ )
+ {
+ }
- using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
+ PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) );
+ }
- VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
- {
- return FormatFeatureFlags( bit0 ) | bit1;
- }
+ PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) );
+ return *this;
+ }
- VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
- {
- return ~( FormatFeatureFlags( bits ) );
- }
+ PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- template <> struct FlagTraits<FormatFeatureFlagBits>
- {
- enum
+ PhysicalDeviceDiscardRectanglePropertiesEXT& setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ )
{
- allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR)
- };
- };
+ maxDiscardRectangles = maxDiscardRectangles_;
+ return *this;
+ }
- struct FormatProperties
- {
- operator const VkFormatProperties&() const
+ operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const
{
- return *reinterpret_cast<const VkFormatProperties*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
}
- bool operator==( FormatProperties const& rhs ) const
+ bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
{
- return ( linearTilingFeatures == rhs.linearTilingFeatures )
- && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
- && ( bufferFeatures == rhs.bufferFeatures );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
}
- bool operator!=( FormatProperties const& rhs ) const
+ bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
{
return !operator==( rhs );
}
- FormatFeatureFlags linearTilingFeatures;
- FormatFeatureFlags optimalTilingFeatures;
- FormatFeatureFlags bufferFeatures;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t maxDiscardRectangles;
};
- static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
- struct FormatProperties2KHR
+ struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
{
- operator const VkFormatProperties2KHR&() const
+ operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const
{
- return *reinterpret_cast<const VkFormatProperties2KHR*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
}
- bool operator==( FormatProperties2KHR const& rhs ) const
+ bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( formatProperties == rhs.formatProperties );
+ && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
}
- bool operator!=( FormatProperties2KHR const& rhs ) const
+ bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
{
return !operator==( rhs );
}
public:
void* pNext;
- FormatProperties formatProperties;
+ Bool32 perViewPositionAllComponents;
};
- static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
- enum class QueryControlFlagBits
+ enum class SubpassContents
{
- ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
+ eInline = VK_SUBPASS_CONTENTS_INLINE,
+ eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
};
- using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
-
- VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
- {
- return QueryControlFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
+ struct PresentInfoKHR
{
- return ~( QueryControlFlags( bits ) );
- }
+ 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_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , swapchainCount( swapchainCount_ )
+ , pSwapchains( pSwapchains_ )
+ , pImageIndices( pImageIndices_ )
+ , pResults( pResults_ )
+ {
+ }
- template <> struct FlagTraits<QueryControlFlagBits>
- {
- enum
+ PresentInfoKHR( VkPresentInfoKHR const & rhs )
{
- allFlags = VkFlags(QueryControlFlagBits::ePrecise)
- };
- };
+ memcpy( this, &rhs, sizeof(PresentInfoKHR) );
+ }
- enum class QueryResultFlagBits
- {
- e64 = VK_QUERY_RESULT_64_BIT,
- eWait = VK_QUERY_RESULT_WAIT_BIT,
- eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
- ePartial = VK_QUERY_RESULT_PARTIAL_BIT
- };
+ PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PresentInfoKHR) );
+ return *this;
+ }
- using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
+ PresentInfoKHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
- {
- return QueryResultFlags( bit0 ) | bit1;
- }
+ PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ {
+ waitSemaphoreCount = waitSemaphoreCount_;
+ return *this;
+ }
- VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
- {
- return ~( QueryResultFlags( bits ) );
- }
+ PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ {
+ pWaitSemaphores = pWaitSemaphores_;
+ return *this;
+ }
- template <> struct FlagTraits<QueryResultFlagBits>
- {
- enum
+ PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
{
- allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
- };
- };
+ swapchainCount = swapchainCount_;
+ return *this;
+ }
- enum class CommandBufferUsageFlagBits
- {
- eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
- eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
- eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
- };
+ PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
+ {
+ pSwapchains = pSwapchains_;
+ return *this;
+ }
- using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
+ PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
+ {
+ pImageIndices = pImageIndices_;
+ return *this;
+ }
- VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
- {
- return CommandBufferUsageFlags( bit0 ) | bit1;
- }
+ PresentInfoKHR& setPResults( Result* pResults_ )
+ {
+ pResults = pResults_;
+ return *this;
+ }
- VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
- {
- return ~( CommandBufferUsageFlags( bits ) );
- }
+ operator const VkPresentInfoKHR&() const
+ {
+ return *reinterpret_cast<const VkPresentInfoKHR*>(this);
+ }
- template <> struct FlagTraits<CommandBufferUsageFlagBits>
- {
- enum
+ bool operator==( PresentInfoKHR const& rhs ) const
{
- allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
- };
- };
-
- enum class QueryPipelineStatisticFlagBits
- {
- eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
- eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
- eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
- eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
- eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
- eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
- eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
- eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
- eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
- eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
- eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
- };
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+ && ( pWaitSemaphores == rhs.pWaitSemaphores )
+ && ( swapchainCount == rhs.swapchainCount )
+ && ( pSwapchains == rhs.pSwapchains )
+ && ( pImageIndices == rhs.pImageIndices )
+ && ( pResults == rhs.pResults );
+ }
- using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
+ bool operator!=( PresentInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
- {
- return QueryPipelineStatisticFlags( bit0 ) | bit1;
- }
+ private:
+ StructureType sType;
- VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
- {
- return ~( QueryPipelineStatisticFlags( bits ) );
- }
+ public:
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ const Semaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ const SwapchainKHR* pSwapchains;
+ const uint32_t* pImageIndices;
+ Result* pResults;
+ };
+ static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
- template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
+ enum class DynamicState
{
- enum
- {
- allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
- };
+ eViewport = VK_DYNAMIC_STATE_VIEWPORT,
+ eScissor = VK_DYNAMIC_STATE_SCISSOR,
+ eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
+ eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
+ eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+ eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+ eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+ eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+ eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+ eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
+ eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT
};
- struct CommandBufferInheritanceInfo
+ struct PipelineDynamicStateCreateInfo
{
- CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : sType( StructureType::eCommandBufferInheritanceInfo )
+ PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr )
+ : sType( StructureType::ePipelineDynamicStateCreateInfo )
, pNext( nullptr )
- , renderPass( renderPass_ )
- , subpass( subpass_ )
- , framebuffer( framebuffer_ )
- , occlusionQueryEnable( occlusionQueryEnable_ )
- , queryFlags( queryFlags_ )
- , pipelineStatistics( pipelineStatistics_ )
+ , flags( flags_ )
+ , dynamicStateCount( dynamicStateCount_ )
+ , pDynamicStates( pDynamicStates_ )
{
}
- CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
+ PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
+ memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
}
- CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
+ PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
+ memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
return *this;
}
- CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
+ PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
- {
- renderPass = renderPass_;
- return *this;
- }
-
- CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
- {
- subpass = subpass_;
- return *this;
- }
-
- CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
- {
- framebuffer = framebuffer_;
- return *this;
- }
-
- CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
+ PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
{
- occlusionQueryEnable = occlusionQueryEnable_;
+ flags = flags_;
return *this;
}
- CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
+ PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
{
- queryFlags = queryFlags_;
+ dynamicStateCount = dynamicStateCount_;
return *this;
}
- CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+ PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
{
- pipelineStatistics = pipelineStatistics_;
+ pDynamicStates = pDynamicStates_;
return *this;
}
- operator const VkCommandBufferInheritanceInfo&() const
+ operator const VkPipelineDynamicStateCreateInfo&() const
{
- return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
+ return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
}
- bool operator==( CommandBufferInheritanceInfo const& rhs ) const
+ bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( renderPass == rhs.renderPass )
- && ( subpass == rhs.subpass )
- && ( framebuffer == rhs.framebuffer )
- && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
- && ( queryFlags == rhs.queryFlags )
- && ( pipelineStatistics == rhs.pipelineStatistics );
+ && ( flags == rhs.flags )
+ && ( dynamicStateCount == rhs.dynamicStateCount )
+ && ( pDynamicStates == rhs.pDynamicStates );
}
- bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
+ bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- RenderPass renderPass;
- uint32_t subpass;
- Framebuffer framebuffer;
- Bool32 occlusionQueryEnable;
- QueryControlFlags queryFlags;
- QueryPipelineStatisticFlags pipelineStatistics;
+ PipelineDynamicStateCreateFlags flags;
+ uint32_t dynamicStateCount;
+ const DynamicState* pDynamicStates;
};
- static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
- struct CommandBufferBeginInfo
+ enum class DescriptorUpdateTemplateTypeKHR
{
- CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
- : sType( StructureType::eCommandBufferBeginInfo )
+ eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
+ };
+
+ 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_ )
- , pInheritanceInfo( pInheritanceInfo_ )
+ , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+ , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+ , templateType( templateType_ )
+ , descriptorSetLayout( descriptorSetLayout_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , pipelineLayout( pipelineLayout_ )
+ , set( set_ )
{
}
- CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+ DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
+ memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) );
}
- CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+ DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
+ memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) );
return *this;
}
- CommandBufferBeginInfo& setPNext( const void* pNext_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setFlags( DescriptorUpdateTemplateCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
}
- CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
{
- pInheritanceInfo = pInheritanceInfo_;
+ descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
return *this;
}
- operator const VkCommandBufferBeginInfo&() const
- {
- return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
- }
-
- bool operator==( CommandBufferBeginInfo const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( pInheritanceInfo == rhs.pInheritanceInfo );
- }
-
- bool operator!=( CommandBufferBeginInfo const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- private:
- StructureType sType;
-
- public:
- const void* pNext;
- CommandBufferUsageFlags flags;
- const CommandBufferInheritanceInfo* pInheritanceInfo;
- };
- static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
-
- struct QueryPoolCreateInfo
- {
- QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : sType( StructureType::eQueryPoolCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
- , queryType( queryType_ )
- , queryCount( queryCount_ )
- , pipelineStatistics( pipelineStatistics_ )
- {
- }
-
- QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
- }
-
- QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
+ DescriptorUpdateTemplateCreateInfoKHR& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ )
{
- memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
+ pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
return *this;
}
- QueryPoolCreateInfo& setPNext( const void* pNext_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setTemplateType( DescriptorUpdateTemplateTypeKHR templateType_ )
{
- pNext = pNext_;
+ templateType = templateType_;
return *this;
}
- QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
{
- flags = flags_;
+ descriptorSetLayout = descriptorSetLayout_;
return *this;
}
- QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- queryType = queryType_;
+ pipelineBindPoint = pipelineBindPoint_;
return *this;
}
- QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setPipelineLayout( PipelineLayout pipelineLayout_ )
{
- queryCount = queryCount_;
+ pipelineLayout = pipelineLayout_;
return *this;
}
- QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+ DescriptorUpdateTemplateCreateInfoKHR& setSet( uint32_t set_ )
{
- pipelineStatistics = pipelineStatistics_;
+ set = set_;
return *this;
}
- operator const VkQueryPoolCreateInfo&() const
+ operator const VkDescriptorUpdateTemplateCreateInfoKHR&() const
{
- return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
+ return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>(this);
}
- bool operator==( QueryPoolCreateInfo const& rhs ) const
+ bool operator==( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( queryType == rhs.queryType )
- && ( queryCount == rhs.queryCount )
- && ( pipelineStatistics == rhs.pipelineStatistics );
+ && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
+ && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
+ && ( templateType == rhs.templateType )
+ && ( descriptorSetLayout == rhs.descriptorSetLayout )
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( pipelineLayout == rhs.pipelineLayout )
+ && ( set == rhs.set );
}
- bool operator!=( QueryPoolCreateInfo const& rhs ) const
+ bool operator!=( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- const void* pNext;
- QueryPoolCreateFlags flags;
- QueryType queryType;
- uint32_t queryCount;
- QueryPipelineStatisticFlags pipelineStatistics;
+ void* pNext;
+ DescriptorUpdateTemplateCreateFlagsKHR flags;
+ uint32_t descriptorUpdateEntryCount;
+ const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
+ DescriptorUpdateTemplateTypeKHR templateType;
+ DescriptorSetLayout descriptorSetLayout;
+ PipelineBindPoint pipelineBindPoint;
+ PipelineLayout pipelineLayout;
+ uint32_t set;
};
- static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DescriptorUpdateTemplateCreateInfoKHR ) == sizeof( VkDescriptorUpdateTemplateCreateInfoKHR ), "struct and wrapper have different size!" );
- enum class ImageAspectFlagBits
+ enum class QueueFlagBits
{
- eColor = VK_IMAGE_ASPECT_COLOR_BIT,
- eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
- eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
- eMetadata = VK_IMAGE_ASPECT_METADATA_BIT
+ eGraphics = VK_QUEUE_GRAPHICS_BIT,
+ eCompute = VK_QUEUE_COMPUTE_BIT,
+ eTransfer = VK_QUEUE_TRANSFER_BIT,
+ eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT
};
- using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
+ using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
- VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
{
- return ImageAspectFlags( bit0 ) | bit1;
+ return QueueFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
+ VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
{
- return ~( ImageAspectFlags( bits ) );
+ return ~( QueueFlags( bits ) );
}
- template <> struct FlagTraits<ImageAspectFlagBits>
+ template <> struct FlagTraits<QueueFlagBits>
{
enum
{
- allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata)
+ allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding)
};
};
- struct ImageSubresource
+ struct QueueFamilyProperties
{
- ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 )
- : aspectMask( aspectMask_ )
- , mipLevel( mipLevel_ )
- , arrayLayer( arrayLayer_ )
+ operator const VkQueueFamilyProperties&() const
{
+ return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
}
- ImageSubresource( VkImageSubresource const & rhs )
+ bool operator==( QueueFamilyProperties const& rhs ) const
{
- memcpy( this, &rhs, sizeof(ImageSubresource) );
+ return ( queueFlags == rhs.queueFlags )
+ && ( queueCount == rhs.queueCount )
+ && ( timestampValidBits == rhs.timestampValidBits )
+ && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
}
- ImageSubresource& operator=( VkImageSubresource const & rhs )
+ bool operator!=( QueueFamilyProperties const& rhs ) const
{
- memcpy( this, &rhs, sizeof(ImageSubresource) );
- return *this;
+ return !operator==( rhs );
}
- ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
- {
- aspectMask = aspectMask_;
- return *this;
- }
+ QueueFlags queueFlags;
+ uint32_t queueCount;
+ uint32_t timestampValidBits;
+ Extent3D minImageTransferGranularity;
+ };
+ static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
- ImageSubresource& setMipLevel( uint32_t mipLevel_ )
+ struct QueueFamilyProperties2KHR
+ {
+ operator const VkQueueFamilyProperties2KHR&() const
{
- mipLevel = mipLevel_;
- return *this;
+ return *reinterpret_cast<const VkQueueFamilyProperties2KHR*>(this);
}
- ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
+ bool operator==( QueueFamilyProperties2KHR const& rhs ) const
{
- arrayLayer = arrayLayer_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( queueFamilyProperties == rhs.queueFamilyProperties );
}
- operator const VkImageSubresource&() const
+ bool operator!=( QueueFamilyProperties2KHR const& rhs ) const
{
- return *reinterpret_cast<const VkImageSubresource*>(this);
+ return !operator==( rhs );
}
- bool operator==( ImageSubresource const& rhs ) const
- {
- return ( aspectMask == rhs.aspectMask )
- && ( mipLevel == rhs.mipLevel )
- && ( arrayLayer == rhs.arrayLayer );
- }
+ private:
+ StructureType sType;
- bool operator!=( ImageSubresource const& rhs ) const
- {
- return !operator==( rhs );
- }
+ public:
+ void* pNext;
+ QueueFamilyProperties queueFamilyProperties;
+ };
+ static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" );
- ImageAspectFlags aspectMask;
- uint32_t mipLevel;
- uint32_t arrayLayer;
+ enum class MemoryPropertyFlagBits
+ {
+ eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+ eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+ eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+ eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
+ eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
};
- static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
- struct ImageSubresourceLayers
+ using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
+
+ VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
{
- ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
- : aspectMask( aspectMask_ )
- , mipLevel( mipLevel_ )
- , baseArrayLayer( baseArrayLayer_ )
- , layerCount( layerCount_ )
- {
- }
+ return MemoryPropertyFlags( bit0 ) | bit1;
+ }
- ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
- {
- memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
- }
+ VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
+ {
+ return ~( MemoryPropertyFlags( bits ) );
+ }
- ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
+ template <> struct FlagTraits<MemoryPropertyFlagBits>
+ {
+ enum
{
- memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
- return *this;
- }
+ allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated)
+ };
+ };
- ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
+ struct MemoryType
+ {
+ operator const VkMemoryType&() const
{
- aspectMask = aspectMask_;
- return *this;
+ return *reinterpret_cast<const VkMemoryType*>(this);
}
- ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
+ bool operator==( MemoryType const& rhs ) const
{
- mipLevel = mipLevel_;
- return *this;
+ return ( propertyFlags == rhs.propertyFlags )
+ && ( heapIndex == rhs.heapIndex );
}
- ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
+ bool operator!=( MemoryType const& rhs ) const
{
- baseArrayLayer = baseArrayLayer_;
- return *this;
+ return !operator==( rhs );
}
- ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
+ MemoryPropertyFlags propertyFlags;
+ uint32_t heapIndex;
+ };
+ static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
+
+ enum class MemoryHeapFlagBits
+ {
+ eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
+ eMultiInstanceKHX = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX
+ };
+
+ using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
+
+ VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
+ {
+ return ~( MemoryHeapFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<MemoryHeapFlagBits>
+ {
+ enum
{
- layerCount = layerCount_;
- return *this;
- }
+ allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstanceKHX)
+ };
+ };
- operator const VkImageSubresourceLayers&() const
+ struct MemoryHeap
+ {
+ operator const VkMemoryHeap&() const
{
- return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
+ return *reinterpret_cast<const VkMemoryHeap*>(this);
}
- bool operator==( ImageSubresourceLayers const& rhs ) const
+ bool operator==( MemoryHeap const& rhs ) const
{
- return ( aspectMask == rhs.aspectMask )
- && ( mipLevel == rhs.mipLevel )
- && ( baseArrayLayer == rhs.baseArrayLayer )
- && ( layerCount == rhs.layerCount );
+ return ( size == rhs.size )
+ && ( flags == rhs.flags );
}
- bool operator!=( ImageSubresourceLayers const& rhs ) const
+ bool operator!=( MemoryHeap const& rhs ) const
{
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
- uint32_t mipLevel;
- uint32_t baseArrayLayer;
- uint32_t layerCount;
+ DeviceSize size;
+ MemoryHeapFlags flags;
};
- static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
- struct ImageSubresourceRange
+ struct PhysicalDeviceMemoryProperties
{
- ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
- : aspectMask( aspectMask_ )
- , baseMipLevel( baseMipLevel_ )
- , levelCount( levelCount_ )
- , baseArrayLayer( baseArrayLayer_ )
- , layerCount( layerCount_ )
- {
- }
-
- ImageSubresourceRange( VkImageSubresourceRange const & rhs )
+ operator const VkPhysicalDeviceMemoryProperties&() const
{
- memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
+ return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
}
- ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
+ bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
{
- memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
- return *this;
+ return ( memoryTypeCount == rhs.memoryTypeCount )
+ && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
+ && ( memoryHeapCount == rhs.memoryHeapCount )
+ && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
}
- ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
+ bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
{
- aspectMask = aspectMask_;
- return *this;
+ return !operator==( rhs );
}
- ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
- {
- baseMipLevel = baseMipLevel_;
- return *this;
- }
+ uint32_t memoryTypeCount;
+ MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ uint32_t memoryHeapCount;
+ MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
+ };
+ static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
- ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
+ struct PhysicalDeviceMemoryProperties2KHR
+ {
+ operator const VkPhysicalDeviceMemoryProperties2KHR&() const
{
- levelCount = levelCount_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2KHR*>(this);
}
- ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
+ bool operator==( PhysicalDeviceMemoryProperties2KHR const& rhs ) const
{
- baseArrayLayer = baseArrayLayer_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memoryProperties == rhs.memoryProperties );
}
- ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
+ bool operator!=( PhysicalDeviceMemoryProperties2KHR const& rhs ) const
{
- layerCount = layerCount_;
- return *this;
+ return !operator==( rhs );
}
- operator const VkImageSubresourceRange&() const
- {
- return *reinterpret_cast<const VkImageSubresourceRange*>(this);
- }
+ private:
+ StructureType sType;
- bool operator==( ImageSubresourceRange const& rhs ) const
- {
- return ( aspectMask == rhs.aspectMask )
- && ( baseMipLevel == rhs.baseMipLevel )
- && ( levelCount == rhs.levelCount )
- && ( baseArrayLayer == rhs.baseArrayLayer )
- && ( layerCount == rhs.layerCount );
- }
+ public:
+ void* pNext;
+ PhysicalDeviceMemoryProperties memoryProperties;
+ };
+ static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" );
- bool operator!=( ImageSubresourceRange const& rhs ) const
- {
- return !operator==( rhs );
- }
+ enum class AccessFlagBits
+ {
+ eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+ eIndexRead = VK_ACCESS_INDEX_READ_BIT,
+ eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+ eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
+ eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+ eShaderRead = VK_ACCESS_SHADER_READ_BIT,
+ eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
+ eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+ eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+ eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+ eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+ eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
+ eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
+ eHostRead = VK_ACCESS_HOST_READ_BIT,
+ eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
+ eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
+ eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
+ eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
+ eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX
+ };
- ImageAspectFlags aspectMask;
- uint32_t baseMipLevel;
- uint32_t levelCount;
- uint32_t baseArrayLayer;
- uint32_t layerCount;
+ using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
+
+ VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
+ {
+ return ~( AccessFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<AccessFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX)
+ };
};
- static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
- struct ImageMemoryBarrier
+ struct MemoryBarrier
{
- 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 )
+ MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() )
+ : sType( StructureType::eMemoryBarrier )
, pNext( nullptr )
, srcAccessMask( srcAccessMask_ )
, dstAccessMask( dstAccessMask_ )
- , oldLayout( oldLayout_ )
- , newLayout( newLayout_ )
- , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
- , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
- , image( image_ )
- , subresourceRange( subresourceRange_ )
{
}
- ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+ MemoryBarrier( VkMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
+ memcpy( this, &rhs, sizeof(MemoryBarrier) );
}
- ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+ MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
+ memcpy( this, &rhs, sizeof(MemoryBarrier) );
return *this;
}
- ImageMemoryBarrier& setPNext( const void* pNext_ )
+ MemoryBarrier& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
{
srcAccessMask = srcAccessMask_;
return *this;
}
- ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
{
dstAccessMask = dstAccessMask_;
return *this;
}
- ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
- {
- oldLayout = oldLayout_;
- return *this;
- }
-
- ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
- {
- newLayout = newLayout_;
- return *this;
- }
-
- ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
- {
- srcQueueFamilyIndex = srcQueueFamilyIndex_;
- return *this;
- }
-
- ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
- {
- dstQueueFamilyIndex = dstQueueFamilyIndex_;
- return *this;
- }
-
- ImageMemoryBarrier& setImage( Image image_ )
- {
- image = image_;
- return *this;
- }
-
- ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
- {
- subresourceRange = subresourceRange_;
- return *this;
- }
-
- operator const VkImageMemoryBarrier&() const
+ operator const VkMemoryBarrier&() const
{
- return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
+ return *reinterpret_cast<const VkMemoryBarrier*>(this);
}
- bool operator==( ImageMemoryBarrier const& rhs ) const
+ bool operator==( MemoryBarrier const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( oldLayout == rhs.oldLayout )
- && ( newLayout == rhs.newLayout )
- && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
- && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
- && ( image == rhs.image )
- && ( subresourceRange == rhs.subresourceRange );
+ && ( dstAccessMask == rhs.dstAccessMask );
}
- bool operator!=( ImageMemoryBarrier const& rhs ) const
+ bool operator!=( MemoryBarrier const& rhs ) const
{
return !operator==( rhs );
}
const void* pNext;
AccessFlags srcAccessMask;
AccessFlags dstAccessMask;
- ImageLayout oldLayout;
- ImageLayout newLayout;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- Image image;
- ImageSubresourceRange subresourceRange;
};
- static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
- struct ImageViewCreateInfo
+ struct BufferMemoryBarrier
{
- ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
- : sType( StructureType::eImageViewCreateInfo )
+ 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 )
- , flags( flags_ )
- , image( image_ )
- , viewType( viewType_ )
- , format( format_ )
- , components( components_ )
- , subresourceRange( subresourceRange_ )
+ , srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+ , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+ , buffer( buffer_ )
+ , offset( offset_ )
+ , size( size_ )
{
}
- ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
+ BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
+ memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
}
- ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+ BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
+ memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
return *this;
}
- ImageViewCreateInfo& setPNext( const void* pNext_ )
+ BufferMemoryBarrier& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
+ BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
{
- flags = flags_;
+ srcAccessMask = srcAccessMask_;
return *this;
}
- ImageViewCreateInfo& setImage( Image image_ )
+ BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
{
- image = image_;
+ dstAccessMask = dstAccessMask_;
return *this;
}
- ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
+ BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
{
- viewType = viewType_;
+ srcQueueFamilyIndex = srcQueueFamilyIndex_;
return *this;
}
- ImageViewCreateInfo& setFormat( Format format_ )
+ BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
{
- format = format_;
+ dstQueueFamilyIndex = dstQueueFamilyIndex_;
return *this;
}
- ImageViewCreateInfo& setComponents( ComponentMapping components_ )
+ BufferMemoryBarrier& setBuffer( Buffer buffer_ )
{
- components = components_;
+ buffer = buffer_;
return *this;
}
- ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ BufferMemoryBarrier& setOffset( DeviceSize offset_ )
{
- subresourceRange = subresourceRange_;
+ offset = offset_;
return *this;
}
- operator const VkImageViewCreateInfo&() const
+ BufferMemoryBarrier& setSize( DeviceSize size_ )
{
- return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
+ size = size_;
+ return *this;
}
- bool operator==( ImageViewCreateInfo const& rhs ) const
+ operator const VkBufferMemoryBarrier&() const
+ {
+ return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
+ }
+
+ bool operator==( BufferMemoryBarrier const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( image == rhs.image )
- && ( viewType == rhs.viewType )
- && ( format == rhs.format )
- && ( components == rhs.components )
- && ( subresourceRange == rhs.subresourceRange );
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
+ && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
+ && ( buffer == rhs.buffer )
+ && ( offset == rhs.offset )
+ && ( size == rhs.size );
}
- bool operator!=( ImageViewCreateInfo const& rhs ) const
+ bool operator!=( BufferMemoryBarrier const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- ImageViewCreateFlags flags;
- Image image;
- ImageViewType viewType;
- Format format;
- ComponentMapping components;
- ImageSubresourceRange subresourceRange;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ Buffer buffer;
+ DeviceSize offset;
+ DeviceSize size;
};
- static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
- struct ImageCopy
+ enum class BufferUsageFlagBits
{
- ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
- : srcSubresource( srcSubresource_ )
- , srcOffset( srcOffset_ )
- , dstSubresource( dstSubresource_ )
- , dstOffset( dstOffset_ )
- , extent( extent_ )
- {
- }
-
- ImageCopy( VkImageCopy const & rhs )
- {
- memcpy( this, &rhs, sizeof(ImageCopy) );
- }
+ eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+ eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+ eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
+ eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+ eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+ eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+ eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+ eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+ eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
+ };
- ImageCopy& operator=( VkImageCopy const & rhs )
- {
- memcpy( this, &rhs, sizeof(ImageCopy) );
- return *this;
- }
+ using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
- ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
- {
- srcSubresource = srcSubresource_;
- return *this;
- }
+ VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) | bit1;
+ }
- ImageCopy& setSrcOffset( Offset3D srcOffset_ )
- {
- srcOffset = srcOffset_;
- return *this;
- }
+ VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
+ {
+ return ~( BufferUsageFlags( bits ) );
+ }
- ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ template <> struct FlagTraits<BufferUsageFlagBits>
+ {
+ enum
{
- dstSubresource = dstSubresource_;
- return *this;
- }
+ allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer)
+ };
+ };
- ImageCopy& setDstOffset( Offset3D dstOffset_ )
- {
- dstOffset = dstOffset_;
- return *this;
- }
+ enum class BufferCreateFlagBits
+ {
+ eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+ eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
+ eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
+ };
- ImageCopy& setExtent( Extent3D extent_ )
+ using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
+
+ VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
+ {
+ return ~( BufferCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<BufferCreateFlagBits>
+ {
+ enum
{
- extent = extent_;
- return *this;
- }
+ allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased)
+ };
+ };
- operator const VkImageCopy&() const
+ 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_ )
+ , size( size_ )
+ , usage( usage_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
{
- return *reinterpret_cast<const VkImageCopy*>(this);
}
- bool operator==( ImageCopy const& rhs ) const
+ BufferCreateInfo( VkBufferCreateInfo const & rhs )
{
- return ( srcSubresource == rhs.srcSubresource )
- && ( srcOffset == rhs.srcOffset )
- && ( dstSubresource == rhs.dstSubresource )
- && ( dstOffset == rhs.dstOffset )
- && ( extent == rhs.extent );
+ memcpy( this, &rhs, sizeof(BufferCreateInfo) );
}
- bool operator!=( ImageCopy const& rhs ) const
+ BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(BufferCreateInfo) );
+ return *this;
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffset;
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffset;
- Extent3D extent;
- };
- static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
-
- struct ImageBlit
- {
- ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
- : srcSubresource( srcSubresource_ )
- , dstSubresource( dstSubresource_ )
+ BufferCreateInfo& setPNext( const void* pNext_ )
{
- memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
- memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ pNext = pNext_;
+ return *this;
}
- ImageBlit( VkImageBlit const & rhs )
+ BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
{
- memcpy( this, &rhs, sizeof(ImageBlit) );
+ flags = flags_;
+ return *this;
}
- ImageBlit& operator=( VkImageBlit const & rhs )
+ BufferCreateInfo& setSize( DeviceSize size_ )
{
- memcpy( this, &rhs, sizeof(ImageBlit) );
+ size = size_;
return *this;
}
- ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
{
- srcSubresource = srcSubresource_;
+ usage = usage_;
return *this;
}
- ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+ BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
{
- memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+ sharingMode = sharingMode_;
return *this;
}
- ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
{
- dstSubresource = dstSubresource_;
+ queueFamilyIndexCount = queueFamilyIndexCount_;
return *this;
}
- ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+ BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
{
- memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ pQueueFamilyIndices = pQueueFamilyIndices_;
return *this;
}
- operator const VkImageBlit&() const
+ operator const VkBufferCreateInfo&() const
{
- return *reinterpret_cast<const VkImageBlit*>(this);
+ return *reinterpret_cast<const VkBufferCreateInfo*>(this);
}
- bool operator==( ImageBlit const& rhs ) const
+ bool operator==( BufferCreateInfo const& rhs ) const
{
- return ( srcSubresource == rhs.srcSubresource )
- && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
- && ( dstSubresource == rhs.dstSubresource )
- && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( size == rhs.size )
+ && ( usage == rhs.usage )
+ && ( sharingMode == rhs.sharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
}
- bool operator!=( ImageBlit const& rhs ) const
+ bool operator!=( BufferCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffsets[2];
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffsets[2];
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ BufferCreateFlags flags;
+ DeviceSize size;
+ BufferUsageFlags usage;
+ SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
};
- static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
+ static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
- struct BufferImageCopy
+ enum class ShaderStageFlagBits
{
- BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() )
- : bufferOffset( bufferOffset_ )
- , bufferRowLength( bufferRowLength_ )
- , bufferImageHeight( bufferImageHeight_ )
- , imageSubresource( imageSubresource_ )
- , imageOffset( imageOffset_ )
- , imageExtent( imageExtent_ )
+ eVertex = VK_SHADER_STAGE_VERTEX_BIT,
+ eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
+ eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
+ eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
+ eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
+ eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
+ eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
+ eAll = VK_SHADER_STAGE_ALL
+ };
+
+ using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
+
+ VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+ {
+ return ShaderStageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
+ {
+ return ~( ShaderStageFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ShaderStageFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll)
+ };
+ };
+
+ struct DescriptorSetLayoutBinding
+ {
+ DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr )
+ : binding( binding_ )
+ , descriptorType( descriptorType_ )
+ , descriptorCount( descriptorCount_ )
+ , stageFlags( stageFlags_ )
+ , pImmutableSamplers( pImmutableSamplers_ )
{
}
- BufferImageCopy( VkBufferImageCopy const & rhs )
+ DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferImageCopy) );
+ memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
}
- BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
+ DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferImageCopy) );
+ memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
return *this;
}
- BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
+ DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
{
- bufferOffset = bufferOffset_;
+ binding = binding_;
return *this;
}
- BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
+ DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
{
- bufferRowLength = bufferRowLength_;
+ descriptorType = descriptorType_;
return *this;
}
- BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
+ DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
{
- bufferImageHeight = bufferImageHeight_;
+ descriptorCount = descriptorCount_;
return *this;
}
- BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+ DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
{
- imageSubresource = imageSubresource_;
+ stageFlags = stageFlags_;
return *this;
}
- BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
- {
- imageOffset = imageOffset_;
- return *this;
- }
-
- BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
+ DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
{
- imageExtent = imageExtent_;
+ pImmutableSamplers = pImmutableSamplers_;
return *this;
}
- operator const VkBufferImageCopy&() const
+ operator const VkDescriptorSetLayoutBinding&() const
{
- return *reinterpret_cast<const VkBufferImageCopy*>(this);
+ return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
}
- bool operator==( BufferImageCopy const& rhs ) const
+ bool operator==( DescriptorSetLayoutBinding const& rhs ) const
{
- return ( bufferOffset == rhs.bufferOffset )
- && ( bufferRowLength == rhs.bufferRowLength )
- && ( bufferImageHeight == rhs.bufferImageHeight )
- && ( imageSubresource == rhs.imageSubresource )
- && ( imageOffset == rhs.imageOffset )
- && ( imageExtent == rhs.imageExtent );
+ return ( binding == rhs.binding )
+ && ( descriptorType == rhs.descriptorType )
+ && ( descriptorCount == rhs.descriptorCount )
+ && ( stageFlags == rhs.stageFlags )
+ && ( pImmutableSamplers == rhs.pImmutableSamplers );
}
- bool operator!=( BufferImageCopy const& rhs ) const
+ bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
{
return !operator==( rhs );
}
- DeviceSize bufferOffset;
- uint32_t bufferRowLength;
- uint32_t bufferImageHeight;
- ImageSubresourceLayers imageSubresource;
- Offset3D imageOffset;
- Extent3D imageExtent;
+ uint32_t binding;
+ DescriptorType descriptorType;
+ uint32_t descriptorCount;
+ ShaderStageFlags stageFlags;
+ const Sampler* pImmutableSamplers;
};
- static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
- struct ImageResolve
+ struct PipelineShaderStageCreateInfo
{
- ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
- : srcSubresource( srcSubresource_ )
- , srcOffset( srcOffset_ )
- , dstSubresource( dstSubresource_ )
- , dstOffset( dstOffset_ )
- , extent( extent_ )
+ 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_ )
+ , stage( stage_ )
+ , module( module_ )
+ , pName( pName_ )
+ , pSpecializationInfo( pSpecializationInfo_ )
{
}
- ImageResolve( VkImageResolve const & rhs )
+ PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageResolve) );
+ memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
}
- ImageResolve& operator=( VkImageResolve const & rhs )
+ PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageResolve) );
+ memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
return *this;
}
- ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
{
- srcSubresource = srcSubresource_;
+ pNext = pNext_;
return *this;
}
- ImageResolve& setSrcOffset( Offset3D srcOffset_ )
+ PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
{
- srcOffset = srcOffset_;
+ flags = flags_;
return *this;
}
- ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
{
- dstSubresource = dstSubresource_;
+ stage = stage_;
return *this;
}
- ImageResolve& setDstOffset( Offset3D dstOffset_ )
+ PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
{
- dstOffset = dstOffset_;
+ module = module_;
return *this;
}
- ImageResolve& setExtent( Extent3D extent_ )
+ PipelineShaderStageCreateInfo& setPName( const char* pName_ )
{
- extent = extent_;
+ pName = pName_;
return *this;
}
- operator const VkImageResolve&() const
+ PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
{
- return *reinterpret_cast<const VkImageResolve*>(this);
+ pSpecializationInfo = pSpecializationInfo_;
+ return *this;
}
- bool operator==( ImageResolve const& rhs ) const
+ operator const VkPipelineShaderStageCreateInfo&() const
{
- return ( srcSubresource == rhs.srcSubresource )
- && ( srcOffset == rhs.srcOffset )
- && ( dstSubresource == rhs.dstSubresource )
- && ( dstOffset == rhs.dstOffset )
- && ( extent == rhs.extent );
+ return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
}
- bool operator!=( ImageResolve const& rhs ) const
+ bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( stage == rhs.stage )
+ && ( module == rhs.module )
+ && ( pName == rhs.pName )
+ && ( pSpecializationInfo == rhs.pSpecializationInfo );
+ }
+
+ bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffset;
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffset;
- Extent3D extent;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ PipelineShaderStageCreateFlags flags;
+ ShaderStageFlagBits stage;
+ ShaderModule module;
+ const char* pName;
+ const SpecializationInfo* pSpecializationInfo;
};
- static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
- struct ClearAttachment
+ struct PushConstantRange
{
- ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() )
- : aspectMask( aspectMask_ )
- , colorAttachment( colorAttachment_ )
- , clearValue( clearValue_ )
+ PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 )
+ : stageFlags( stageFlags_ )
+ , offset( offset_ )
+ , size( size_ )
{
}
- ClearAttachment( VkClearAttachment const & rhs )
+ PushConstantRange( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearAttachment) );
+ memcpy( this, &rhs, sizeof(PushConstantRange) );
}
- ClearAttachment& operator=( VkClearAttachment const & rhs )
+ PushConstantRange& operator=( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearAttachment) );
+ memcpy( this, &rhs, sizeof(PushConstantRange) );
return *this;
}
- ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
+ PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
{
- aspectMask = aspectMask_;
+ stageFlags = stageFlags_;
return *this;
}
- ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
+ PushConstantRange& setOffset( uint32_t offset_ )
{
- colorAttachment = colorAttachment_;
+ offset = offset_;
return *this;
}
- ClearAttachment& setClearValue( ClearValue clearValue_ )
+ PushConstantRange& setSize( uint32_t size_ )
{
- clearValue = clearValue_;
+ size = size_;
return *this;
}
- operator const VkClearAttachment&() const
+ operator const VkPushConstantRange&() const
{
- return *reinterpret_cast<const VkClearAttachment*>(this);
+ return *reinterpret_cast<const VkPushConstantRange*>(this);
}
- ImageAspectFlags aspectMask;
- uint32_t colorAttachment;
- ClearValue clearValue;
- };
- static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
-
- enum class SparseImageFormatFlagBits
- {
- eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
- eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
- eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
- };
-
- using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
-
- VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
- {
- return SparseImageFormatFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
- {
- return ~( SparseImageFormatFlags( bits ) );
- }
+ bool operator==( PushConstantRange const& rhs ) const
+ {
+ return ( stageFlags == rhs.stageFlags )
+ && ( offset == rhs.offset )
+ && ( size == rhs.size );
+ }
- template <> struct FlagTraits<SparseImageFormatFlagBits>
- {
- enum
+ bool operator!=( PushConstantRange const& rhs ) const
{
- allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
- };
+ return !operator==( rhs );
+ }
+
+ ShaderStageFlags stageFlags;
+ uint32_t offset;
+ uint32_t size;
};
+ static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
- struct SparseImageFormatProperties
+ struct PipelineLayoutCreateInfo
{
- operator const VkSparseImageFormatProperties&() const
+ 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_ )
+ , setLayoutCount( setLayoutCount_ )
+ , pSetLayouts( pSetLayouts_ )
+ , pushConstantRangeCount( pushConstantRangeCount_ )
+ , pPushConstantRanges( pPushConstantRanges_ )
{
- return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
}
- bool operator==( SparseImageFormatProperties const& rhs ) const
+ PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
{
- return ( aspectMask == rhs.aspectMask )
- && ( imageGranularity == rhs.imageGranularity )
- && ( flags == rhs.flags );
+ memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
}
- bool operator!=( SparseImageFormatProperties const& rhs ) const
+ PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
+ return *this;
}
- ImageAspectFlags aspectMask;
- Extent3D imageGranularity;
- SparseImageFormatFlags flags;
- };
- static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
-
- struct SparseImageMemoryRequirements
- {
- operator const VkSparseImageMemoryRequirements&() const
+ PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
{
- return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
+ pNext = pNext_;
+ return *this;
}
- bool operator==( SparseImageMemoryRequirements const& rhs ) const
+ PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
{
- return ( formatProperties == rhs.formatProperties )
- && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
- && ( imageMipTailSize == rhs.imageMipTailSize )
- && ( imageMipTailOffset == rhs.imageMipTailOffset )
- && ( imageMipTailStride == rhs.imageMipTailStride );
+ flags = flags_;
+ return *this;
}
- bool operator!=( SparseImageMemoryRequirements const& rhs ) const
+ PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
{
- return !operator==( rhs );
+ setLayoutCount = setLayoutCount_;
+ return *this;
}
- SparseImageFormatProperties formatProperties;
- uint32_t imageMipTailFirstLod;
- DeviceSize imageMipTailSize;
- DeviceSize imageMipTailOffset;
- DeviceSize imageMipTailStride;
- };
- static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
+ PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+ {
+ pSetLayouts = pSetLayouts_;
+ return *this;
+ }
- struct SparseImageFormatProperties2KHR
- {
- operator const VkSparseImageFormatProperties2KHR&() const
+ PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
{
- return *reinterpret_cast<const VkSparseImageFormatProperties2KHR*>(this);
+ pushConstantRangeCount = pushConstantRangeCount_;
+ return *this;
}
- bool operator==( SparseImageFormatProperties2KHR const& rhs ) const
+ PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+ {
+ pPushConstantRanges = pPushConstantRanges_;
+ return *this;
+ }
+
+ operator const VkPipelineLayoutCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
+ }
+
+ bool operator==( PipelineLayoutCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( properties == rhs.properties );
+ && ( flags == rhs.flags )
+ && ( setLayoutCount == rhs.setLayoutCount )
+ && ( pSetLayouts == rhs.pSetLayouts )
+ && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
+ && ( pPushConstantRanges == rhs.pPushConstantRanges );
}
- bool operator!=( SparseImageFormatProperties2KHR const& rhs ) const
+ bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- void* pNext;
- SparseImageFormatProperties properties;
+ const void* pNext;
+ PipelineLayoutCreateFlags flags;
+ uint32_t setLayoutCount;
+ const DescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const PushConstantRange* pPushConstantRanges;
};
- static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
- enum class SparseMemoryBindFlagBits
+ enum class ImageUsageFlagBits
{
- eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
+ eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+ eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+ eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
+ eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
+ eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+ eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+ eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+ eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
};
- using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
+ using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
- VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
{
- return SparseMemoryBindFlags( bit0 ) | bit1;
+ return ImageUsageFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
+ VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
{
- return ~( SparseMemoryBindFlags( bits ) );
+ return ~( ImageUsageFlags( bits ) );
}
- template <> struct FlagTraits<SparseMemoryBindFlagBits>
+ template <> struct FlagTraits<ImageUsageFlagBits>
{
enum
{
- allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
+ allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment)
};
};
- struct SparseMemoryBind
+ enum class ImageCreateFlagBits
{
- SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
- : resourceOffset( resourceOffset_ )
- , size( size_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
+ eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
+ eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
+ eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
+ eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
+ eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
+ eBindSfrKHX = VK_IMAGE_CREATE_BIND_SFR_BIT_KHX,
+ e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR
+ };
+
+ using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
+
+ VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+ {
+ return ImageCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
+ {
+ return ~( ImageCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ImageCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eBindSfrKHX) | VkFlags(ImageCreateFlagBits::e2DArrayCompatibleKHR)
+ };
+ };
+
+ 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_ )
+ , type( type_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
, flags( flags_ )
{
}
- SparseMemoryBind( VkSparseMemoryBind const & rhs )
+ PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseMemoryBind) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) );
}
- SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
+ PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseMemoryBind) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) );
return *this;
}
- SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
+ PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ )
{
- resourceOffset = resourceOffset_;
+ pNext = pNext_;
return *this;
}
- SparseMemoryBind& setSize( DeviceSize size_ )
+ PhysicalDeviceImageFormatInfo2KHR& setFormat( Format format_ )
{
- size = size_;
+ format = format_;
return *this;
}
- SparseMemoryBind& setMemory( DeviceMemory memory_ )
+ PhysicalDeviceImageFormatInfo2KHR& setType( ImageType type_ )
{
- memory = memory_;
+ type = type_;
return *this;
}
- SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ PhysicalDeviceImageFormatInfo2KHR& setTiling( ImageTiling tiling_ )
{
- memoryOffset = memoryOffset_;
+ tiling = tiling_;
return *this;
}
- SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ PhysicalDeviceImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ PhysicalDeviceImageFormatInfo2KHR& setFlags( ImageCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- operator const VkSparseMemoryBind&() const
+ operator const VkPhysicalDeviceImageFormatInfo2KHR&() const
{
- return *reinterpret_cast<const VkSparseMemoryBind*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>(this);
}
- bool operator==( SparseMemoryBind const& rhs ) const
+ bool operator==( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const
{
- return ( resourceOffset == rhs.resourceOffset )
- && ( size == rhs.size )
- && ( memory == rhs.memory )
- && ( memoryOffset == rhs.memoryOffset )
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( format == rhs.format )
+ && ( type == rhs.type )
+ && ( tiling == rhs.tiling )
+ && ( usage == rhs.usage )
&& ( flags == rhs.flags );
}
- bool operator!=( SparseMemoryBind const& rhs ) const
+ bool operator!=( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const
{
return !operator==( rhs );
}
- DeviceSize resourceOffset;
- DeviceSize size;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- SparseMemoryBindFlags flags;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ Format format;
+ ImageType type;
+ ImageTiling tiling;
+ ImageUsageFlags usage;
+ ImageCreateFlags flags;
};
- static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHR ), "struct and wrapper have different size!" );
- struct SparseImageMemoryBind
+ struct PhysicalDeviceImageFormatInfo2KHX
{
- SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
- : subresource( subresource_ )
- , offset( offset_ )
- , extent( extent_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
+ PhysicalDeviceImageFormatInfo2KHX( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() )
+ : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHX )
+ , pNext( nullptr )
+ , format( format_ )
+ , type( type_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
, flags( flags_ )
{
}
- SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
+ PhysicalDeviceImageFormatInfo2KHX( VkPhysicalDeviceImageFormatInfo2KHX const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHX) );
}
- SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
+ PhysicalDeviceImageFormatInfo2KHX& operator=( VkPhysicalDeviceImageFormatInfo2KHX const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHX) );
return *this;
}
- SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
+ PhysicalDeviceImageFormatInfo2KHX& setPNext( const void* pNext_ )
{
- subresource = subresource_;
+ pNext = pNext_;
return *this;
}
- SparseImageMemoryBind& setOffset( Offset3D offset_ )
+ PhysicalDeviceImageFormatInfo2KHX& setFormat( Format format_ )
{
- offset = offset_;
+ format = format_;
return *this;
}
- SparseImageMemoryBind& setExtent( Extent3D extent_ )
+ PhysicalDeviceImageFormatInfo2KHX& setType( ImageType type_ )
{
- extent = extent_;
+ type = type_;
return *this;
}
- SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
+ PhysicalDeviceImageFormatInfo2KHX& setTiling( ImageTiling tiling_ )
{
- memory = memory_;
+ tiling = tiling_;
return *this;
}
- SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ PhysicalDeviceImageFormatInfo2KHX& setUsage( ImageUsageFlags usage_ )
{
- memoryOffset = memoryOffset_;
+ usage = usage_;
return *this;
}
- SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ PhysicalDeviceImageFormatInfo2KHX& setFlags( ImageCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- operator const VkSparseImageMemoryBind&() const
+ operator const VkPhysicalDeviceImageFormatInfo2KHX&() const
{
- return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHX*>(this);
}
- bool operator==( SparseImageMemoryBind const& rhs ) const
+ bool operator==( PhysicalDeviceImageFormatInfo2KHX const& rhs ) const
{
- return ( subresource == rhs.subresource )
- && ( offset == rhs.offset )
- && ( extent == rhs.extent )
- && ( memory == rhs.memory )
- && ( memoryOffset == rhs.memoryOffset )
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( format == rhs.format )
+ && ( type == rhs.type )
+ && ( tiling == rhs.tiling )
+ && ( usage == rhs.usage )
&& ( flags == rhs.flags );
}
- bool operator!=( SparseImageMemoryBind const& rhs ) const
+ bool operator!=( PhysicalDeviceImageFormatInfo2KHX const& rhs ) const
{
return !operator==( rhs );
}
- ImageSubresource subresource;
- Offset3D offset;
- Extent3D extent;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- SparseMemoryBindFlags flags;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ Format format;
+ ImageType type;
+ ImageTiling tiling;
+ ImageUsageFlags usage;
+ ImageCreateFlags flags;
};
- static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHX ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHX ), "struct and wrapper have different size!" );
- struct SparseBufferMemoryBindInfo
+ enum class PipelineCreateFlagBits
{
- SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
- : buffer( buffer_ )
- , bindCount( bindCount_ )
- , pBinds( pBinds_ )
- {
- }
-
- SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
- }
+ eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
+ eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
+ eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
+ eViewIndexFromDeviceIndexKHX = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX,
+ eDispatchBaseKHX = VK_PIPELINE_CREATE_DISPATCH_BASE_KHX
+ };
- SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
- return *this;
- }
+ using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
- SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
- {
- buffer = buffer_;
- return *this;
- }
+ VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) | bit1;
+ }
- SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
- {
- bindCount = bindCount_;
- return *this;
- }
+ VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
+ {
+ return ~( PipelineCreateFlags( bits ) );
+ }
- SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ template <> struct FlagTraits<PipelineCreateFlagBits>
+ {
+ enum
{
- pBinds = pBinds_;
- return *this;
- }
+ allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) | VkFlags(PipelineCreateFlagBits::eDispatchBaseKHX)
+ };
+ };
- operator const VkSparseBufferMemoryBindInfo&() const
+ 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_ )
+ , stage( stage_ )
+ , layout( layout_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
{
- return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
}
- bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
+ ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
{
- return ( buffer == rhs.buffer )
- && ( bindCount == rhs.bindCount )
- && ( pBinds == rhs.pBinds );
+ memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
}
- bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
+ ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
+ return *this;
}
- Buffer buffer;
- uint32_t bindCount;
- const SparseMemoryBind* pBinds;
- };
- static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
-
- struct SparseImageOpaqueMemoryBindInfo
- {
- SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
- : image( image_ )
- , bindCount( bindCount_ )
- , pBinds( pBinds_ )
+ ComputePipelineCreateInfo& setPNext( const void* pNext_ )
{
+ pNext = pNext_;
+ return *this;
}
- SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
{
- memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
+ flags = flags_;
+ return *this;
}
- SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
{
- memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
+ stage = stage_;
return *this;
}
- SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
+ ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
{
- image = image_;
+ layout = layout_;
return *this;
}
- SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
{
- bindCount = bindCount_;
+ basePipelineHandle = basePipelineHandle_;
return *this;
}
- SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
{
- pBinds = pBinds_;
+ basePipelineIndex = basePipelineIndex_;
return *this;
}
- operator const VkSparseImageOpaqueMemoryBindInfo&() const
+ operator const VkComputePipelineCreateInfo&() const
{
- return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
+ return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
}
- bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ bool operator==( ComputePipelineCreateInfo const& rhs ) const
{
- return ( image == rhs.image )
- && ( bindCount == rhs.bindCount )
- && ( pBinds == rhs.pBinds );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( stage == rhs.stage )
+ && ( layout == rhs.layout )
+ && ( basePipelineHandle == rhs.basePipelineHandle )
+ && ( basePipelineIndex == rhs.basePipelineIndex );
}
- bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ bool operator!=( ComputePipelineCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- Image image;
- uint32_t bindCount;
- const SparseMemoryBind* pBinds;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ PipelineCreateFlags flags;
+ PipelineShaderStageCreateInfo stage;
+ PipelineLayout layout;
+ Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
};
- static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
- struct SparseImageMemoryBindInfo
+ enum class ColorComponentFlagBits
{
- SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr )
- : image( image_ )
- , bindCount( bindCount_ )
- , pBinds( pBinds_ )
- {
- }
+ eR = VK_COLOR_COMPONENT_R_BIT,
+ eG = VK_COLOR_COMPONENT_G_BIT,
+ eB = VK_COLOR_COMPONENT_B_BIT,
+ eA = VK_COLOR_COMPONENT_A_BIT
+ };
- SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
+ using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
+
+ VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
+ {
+ return ~( ColorComponentFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ColorComponentFlagBits>
+ {
+ enum
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
- }
+ allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
+ };
+ };
- SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
+ struct PipelineColorBlendAttachmentState
+ {
+ PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, BlendOp colorBlendOp_ = BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, BlendOp alphaBlendOp_ = BlendOp::eAdd, ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
+ : blendEnable( blendEnable_ )
+ , srcColorBlendFactor( srcColorBlendFactor_ )
+ , dstColorBlendFactor( dstColorBlendFactor_ )
+ , colorBlendOp( colorBlendOp_ )
+ , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
+ , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
+ , alphaBlendOp( alphaBlendOp_ )
+ , colorWriteMask( colorWriteMask_ )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
- return *this;
}
- SparseImageMemoryBindInfo& setImage( Image image_ )
+ PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
{
- image = image_;
- return *this;
+ memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
}
- SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
{
- bindCount = bindCount_;
+ memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
return *this;
}
- SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
+ PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
{
- pBinds = pBinds_;
+ blendEnable = blendEnable_;
return *this;
}
- operator const VkSparseImageMemoryBindInfo&() const
+ PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
{
- return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
+ srcColorBlendFactor = srcColorBlendFactor_;
+ return *this;
}
- bool operator==( SparseImageMemoryBindInfo const& rhs ) const
+ PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
{
- return ( image == rhs.image )
- && ( bindCount == rhs.bindCount )
- && ( pBinds == rhs.pBinds );
+ dstColorBlendFactor = dstColorBlendFactor_;
+ return *this;
}
- bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
+ PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
{
- return !operator==( rhs );
+ colorBlendOp = colorBlendOp_;
+ return *this;
}
- Image image;
- uint32_t bindCount;
- const SparseImageMemoryBind* pBinds;
- };
- static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "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_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , bufferBindCount( bufferBindCount_ )
- , pBufferBinds( pBufferBinds_ )
- , imageOpaqueBindCount( imageOpaqueBindCount_ )
- , pImageOpaqueBinds( pImageOpaqueBinds_ )
- , imageBindCount( imageBindCount_ )
- , pImageBinds( pImageBinds_ )
- , signalSemaphoreCount( signalSemaphoreCount_ )
- , pSignalSemaphores( pSignalSemaphores_ )
+ PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
{
+ srcAlphaBlendFactor = srcAlphaBlendFactor_;
+ return *this;
}
- BindSparseInfo( VkBindSparseInfo const & rhs )
+ PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
{
- memcpy( this, &rhs, sizeof(BindSparseInfo) );
+ dstAlphaBlendFactor = dstAlphaBlendFactor_;
+ return *this;
}
- BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
+ PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
{
- memcpy( this, &rhs, sizeof(BindSparseInfo) );
+ alphaBlendOp = alphaBlendOp_;
return *this;
}
- BindSparseInfo& setPNext( const void* pNext_ )
+ PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
{
- pNext = pNext_;
+ colorWriteMask = colorWriteMask_;
return *this;
}
- BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ operator const VkPipelineColorBlendAttachmentState&() const
{
- waitSemaphoreCount = waitSemaphoreCount_;
- return *this;
+ return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
}
- BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
{
- pWaitSemaphores = pWaitSemaphores_;
- return *this;
+ return ( blendEnable == rhs.blendEnable )
+ && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
+ && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
+ && ( colorBlendOp == rhs.colorBlendOp )
+ && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
+ && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
+ && ( alphaBlendOp == rhs.alphaBlendOp )
+ && ( colorWriteMask == rhs.colorWriteMask );
}
- BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
+ bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
{
- bufferBindCount = bufferBindCount_;
+ return !operator==( rhs );
+ }
+
+ Bool32 blendEnable;
+ BlendFactor srcColorBlendFactor;
+ BlendFactor dstColorBlendFactor;
+ BlendOp colorBlendOp;
+ BlendFactor srcAlphaBlendFactor;
+ BlendFactor dstAlphaBlendFactor;
+ BlendOp alphaBlendOp;
+ ColorComponentFlags colorWriteMask;
+ };
+ static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
+
+ 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_ )
+ , logicOpEnable( logicOpEnable_ )
+ , logicOp( logicOp_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ {
+ memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
+ }
+
+ PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
+ }
+
+ PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
return *this;
}
- BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+ PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
{
- pBufferBinds = pBufferBinds_;
+ pNext = pNext_;
return *this;
}
- BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
+ PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
{
- imageOpaqueBindCount = imageOpaqueBindCount_;
+ flags = flags_;
return *this;
}
- BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+ PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
{
- pImageOpaqueBinds = pImageOpaqueBinds_;
+ logicOpEnable = logicOpEnable_;
return *this;
}
- BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
+ PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
{
- imageBindCount = imageBindCount_;
+ logicOp = logicOp_;
return *this;
}
- BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+ PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
{
- pImageBinds = pImageBinds_;
+ attachmentCount = attachmentCount_;
return *this;
}
- BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+ PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
{
- signalSemaphoreCount = signalSemaphoreCount_;
+ pAttachments = pAttachments_;
return *this;
}
- BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+ PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
{
- pSignalSemaphores = pSignalSemaphores_;
+ memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
return *this;
}
- operator const VkBindSparseInfo&() const
+ operator const VkPipelineColorBlendStateCreateInfo&() const
{
- return *reinterpret_cast<const VkBindSparseInfo*>(this);
+ return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
}
- bool operator==( BindSparseInfo const& rhs ) const
+ bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
- && ( pWaitSemaphores == rhs.pWaitSemaphores )
- && ( bufferBindCount == rhs.bufferBindCount )
- && ( pBufferBinds == rhs.pBufferBinds )
- && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
- && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
- && ( imageBindCount == rhs.imageBindCount )
- && ( pImageBinds == rhs.pImageBinds )
- && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
- && ( pSignalSemaphores == rhs.pSignalSemaphores );
+ && ( flags == rhs.flags )
+ && ( logicOpEnable == rhs.logicOpEnable )
+ && ( logicOp == rhs.logicOp )
+ && ( attachmentCount == rhs.attachmentCount )
+ && ( pAttachments == rhs.pAttachments )
+ && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
}
- bool operator!=( BindSparseInfo const& rhs ) const
+ bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- uint32_t bufferBindCount;
- const SparseBufferMemoryBindInfo* pBufferBinds;
- uint32_t imageOpaqueBindCount;
- const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
- uint32_t imageBindCount;
- const SparseImageMemoryBindInfo* pImageBinds;
- uint32_t signalSemaphoreCount;
- const Semaphore* pSignalSemaphores;
- };
- static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
-
- enum class PipelineStageFlagBits
- {
- eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
- eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
- eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
- eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
- eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
- eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
- eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
- eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
- eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
- eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
- eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
- eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
- eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
- eHost = VK_PIPELINE_STAGE_HOST_BIT,
- eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
- eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
- };
-
- using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
-
- VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
- {
- return PipelineStageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
- {
- return ~( PipelineStageFlags( bits ) );
- }
-
- template <> struct FlagTraits<PipelineStageFlagBits>
- {
- enum
- {
- allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX)
- };
+ PipelineColorBlendStateCreateFlags flags;
+ Bool32 logicOpEnable;
+ LogicOp logicOp;
+ uint32_t attachmentCount;
+ const PipelineColorBlendAttachmentState* pAttachments;
+ float blendConstants[4];
};
+ static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
- enum class CommandPoolCreateFlagBits
+ enum class FenceCreateFlagBits
{
- eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
- eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
+ eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
};
- using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
+ using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
- VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
{
- return CommandPoolCreateFlags( bit0 ) | bit1;
+ return FenceCreateFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
+ VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
{
- return ~( CommandPoolCreateFlags( bits ) );
+ return ~( FenceCreateFlags( bits ) );
}
- template <> struct FlagTraits<CommandPoolCreateFlagBits>
+ template <> struct FlagTraits<FenceCreateFlagBits>
{
enum
{
- allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer)
+ allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
};
};
- struct CommandPoolCreateInfo
+ struct FenceCreateInfo
{
- CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 )
- : sType( StructureType::eCommandPoolCreateInfo )
+ FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
+ : sType( StructureType::eFenceCreateInfo )
, pNext( nullptr )
, flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
{
}
- CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+ FenceCreateInfo( VkFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof(FenceCreateInfo) );
}
- CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+ FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof(FenceCreateInfo) );
return *this;
}
- CommandPoolCreateInfo& setPNext( const void* pNext_ )
+ FenceCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
+ FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
- {
- queueFamilyIndex = queueFamilyIndex_;
- return *this;
- }
-
- operator const VkCommandPoolCreateInfo&() const
+ operator const VkFenceCreateInfo&() const
{
- return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
+ return *reinterpret_cast<const VkFenceCreateInfo*>(this);
}
- bool operator==( CommandPoolCreateInfo const& rhs ) const
+ bool operator==( FenceCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( queueFamilyIndex == rhs.queueFamilyIndex );
+ && ( flags == rhs.flags );
}
- bool operator!=( CommandPoolCreateInfo const& rhs ) const
+ bool operator!=( FenceCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- CommandPoolCreateFlags flags;
- uint32_t queueFamilyIndex;
+ FenceCreateFlags flags;
};
- static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
- enum class CommandPoolResetFlagBits
+ enum class FormatFeatureFlagBits
{
- eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
+ eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
+ eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
+ eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
+ eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
+ eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
+ eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
+ eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
+ eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
+ eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
+ eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
+ eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
+ eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
+ eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
+ eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
+ eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR,
+ eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR
};
- using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
+ using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
- VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
{
- return CommandPoolResetFlags( bit0 ) | bit1;
+ return FormatFeatureFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
+ VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
{
- return ~( CommandPoolResetFlags( bits ) );
+ return ~( FormatFeatureFlags( bits ) );
}
- template <> struct FlagTraits<CommandPoolResetFlagBits>
+ template <> struct FlagTraits<FormatFeatureFlagBits>
{
enum
{
- allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
+ allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR)
};
};
- enum class CommandBufferResetFlagBits
+ struct FormatProperties
{
- eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+ operator const VkFormatProperties&() const
+ {
+ return *reinterpret_cast<const VkFormatProperties*>(this);
+ }
+
+ bool operator==( FormatProperties const& rhs ) const
+ {
+ return ( linearTilingFeatures == rhs.linearTilingFeatures )
+ && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
+ && ( bufferFeatures == rhs.bufferFeatures );
+ }
+
+ bool operator!=( FormatProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ FormatFeatureFlags linearTilingFeatures;
+ FormatFeatureFlags optimalTilingFeatures;
+ FormatFeatureFlags bufferFeatures;
};
+ static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
- using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
+ struct FormatProperties2KHR
+ {
+ operator const VkFormatProperties2KHR&() const
+ {
+ return *reinterpret_cast<const VkFormatProperties2KHR*>(this);
+ }
- VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ bool operator==( FormatProperties2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( formatProperties == rhs.formatProperties );
+ }
+
+ bool operator!=( FormatProperties2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ FormatProperties formatProperties;
+ };
+ static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" );
+
+ enum class QueryControlFlagBits
{
- return CommandBufferResetFlags( bit0 ) | bit1;
+ ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
+ };
+
+ using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
+
+ VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+ {
+ return QueryControlFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+ VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
{
- return ~( CommandBufferResetFlags( bits ) );
+ return ~( QueryControlFlags( bits ) );
}
- template <> struct FlagTraits<CommandBufferResetFlagBits>
+ template <> struct FlagTraits<QueryControlFlagBits>
{
enum
{
- allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
+ allFlags = VkFlags(QueryControlFlagBits::ePrecise)
};
};
- enum class SampleCountFlagBits
+ enum class QueryResultFlagBits
{
- e1 = VK_SAMPLE_COUNT_1_BIT,
- e2 = VK_SAMPLE_COUNT_2_BIT,
- e4 = VK_SAMPLE_COUNT_4_BIT,
- e8 = VK_SAMPLE_COUNT_8_BIT,
- e16 = VK_SAMPLE_COUNT_16_BIT,
- e32 = VK_SAMPLE_COUNT_32_BIT,
- e64 = VK_SAMPLE_COUNT_64_BIT
+ e64 = VK_QUERY_RESULT_64_BIT,
+ eWait = VK_QUERY_RESULT_WAIT_BIT,
+ eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
+ ePartial = VK_QUERY_RESULT_PARTIAL_BIT
};
- using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
+ using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
- VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
{
- return SampleCountFlags( bit0 ) | bit1;
+ return QueryResultFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
+ VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
{
- return ~( SampleCountFlags( bits ) );
+ return ~( QueryResultFlags( bits ) );
}
- template <> struct FlagTraits<SampleCountFlagBits>
+ template <> struct FlagTraits<QueryResultFlagBits>
{
enum
{
- allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
+ allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
};
};
- struct ImageFormatProperties
+ enum class CommandBufferUsageFlagBits
{
- operator const VkImageFormatProperties&() const
- {
- return *reinterpret_cast<const VkImageFormatProperties*>(this);
- }
+ eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+ eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
+ eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
+ };
- bool operator==( ImageFormatProperties const& rhs ) const
- {
- return ( maxExtent == rhs.maxExtent )
- && ( maxMipLevels == rhs.maxMipLevels )
- && ( maxArrayLayers == rhs.maxArrayLayers )
- && ( sampleCounts == rhs.sampleCounts )
- && ( maxResourceSize == rhs.maxResourceSize );
- }
+ using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
- bool operator!=( ImageFormatProperties const& rhs ) const
+ VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+ {
+ return CommandBufferUsageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
+ {
+ return ~( CommandBufferUsageFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandBufferUsageFlagBits>
+ {
+ enum
{
- return !operator==( rhs );
- }
+ allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
+ };
+ };
- Extent3D maxExtent;
- uint32_t maxMipLevels;
- uint32_t maxArrayLayers;
- SampleCountFlags sampleCounts;
- DeviceSize maxResourceSize;
+ enum class QueryPipelineStatisticFlagBits
+ {
+ eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
+ eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
+ eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
+ eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
+ eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
+ eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
+ eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
+ eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
+ eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
+ eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
+ eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
};
- static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
- struct ImageCreateInfo
+ using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
+
+ VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
{
- 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 )
+ return QueryPipelineStatisticFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
+ {
+ return ~( QueryPipelineStatisticFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
+ };
+ };
+
+ 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 )
- , flags( flags_ )
- , imageType( imageType_ )
- , format( format_ )
- , extent( extent_ )
- , mipLevels( mipLevels_ )
- , arrayLayers( arrayLayers_ )
- , samples( samples_ )
- , tiling( tiling_ )
- , usage( usage_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
- , initialLayout( initialLayout_ )
+ , renderPass( renderPass_ )
+ , subpass( subpass_ )
+ , framebuffer( framebuffer_ )
+ , occlusionQueryEnable( occlusionQueryEnable_ )
+ , queryFlags( queryFlags_ )
+ , pipelineStatistics( pipelineStatistics_ )
{
}
- ImageCreateInfo( VkImageCreateInfo const & rhs )
+ CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageCreateInfo) );
+ memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
}
- ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+ CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageCreateInfo) );
+ memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
return *this;
}
- ImageCreateInfo& setPNext( const void* pNext_ )
+ CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
+ CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
{
- flags = flags_;
+ renderPass = renderPass_;
return *this;
}
- ImageCreateInfo& setImageType( ImageType imageType_ )
+ CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
{
- imageType = imageType_;
+ subpass = subpass_;
return *this;
}
- ImageCreateInfo& setFormat( Format format_ )
+ CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
{
- format = format_;
+ framebuffer = framebuffer_;
return *this;
}
- ImageCreateInfo& setExtent( Extent3D extent_ )
+ CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
{
- extent = extent_;
+ occlusionQueryEnable = occlusionQueryEnable_;
return *this;
}
- ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
+ CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
{
- mipLevels = mipLevels_;
+ queryFlags = queryFlags_;
return *this;
}
- ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
+ CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
{
- arrayLayers = arrayLayers_;
+ pipelineStatistics = pipelineStatistics_;
return *this;
}
- ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
+ operator const VkCommandBufferInheritanceInfo&() const
{
- samples = samples_;
- return *this;
+ return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
}
- ImageCreateInfo& setTiling( ImageTiling tiling_ )
+ bool operator==( CommandBufferInheritanceInfo const& rhs ) const
{
- tiling = tiling_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( renderPass == rhs.renderPass )
+ && ( subpass == rhs.subpass )
+ && ( framebuffer == rhs.framebuffer )
+ && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
+ && ( queryFlags == rhs.queryFlags )
+ && ( pipelineStatistics == rhs.pipelineStatistics );
}
- ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
+ bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
{
- usage = usage_;
- return *this;
+ return !operator==( rhs );
}
- ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
- {
- sharingMode = sharingMode_;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ RenderPass renderPass;
+ uint32_t subpass;
+ Framebuffer framebuffer;
+ Bool32 occlusionQueryEnable;
+ QueryControlFlags queryFlags;
+ QueryPipelineStatisticFlags pipelineStatistics;
+ };
+ static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
+
+ struct CommandBufferBeginInfo
+ {
+ CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+ : sType( StructureType::eCommandBufferBeginInfo )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , pInheritanceInfo( pInheritanceInfo_ )
+ {
+ }
+
+ CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
+ }
+
+ CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
return *this;
}
- ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ CommandBufferBeginInfo& setPNext( const void* pNext_ )
{
- queueFamilyIndexCount = queueFamilyIndexCount_;
+ pNext = pNext_;
return *this;
}
- ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
{
- pQueueFamilyIndices = pQueueFamilyIndices_;
+ flags = flags_;
return *this;
}
- ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
+ CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
{
- initialLayout = initialLayout_;
+ pInheritanceInfo = pInheritanceInfo_;
return *this;
}
- operator const VkImageCreateInfo&() const
+ operator const VkCommandBufferBeginInfo&() const
{
- return *reinterpret_cast<const VkImageCreateInfo*>(this);
+ return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
}
- bool operator==( ImageCreateInfo const& rhs ) const
+ bool operator==( CommandBufferBeginInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( imageType == rhs.imageType )
- && ( format == rhs.format )
- && ( extent == rhs.extent )
- && ( mipLevels == rhs.mipLevels )
- && ( arrayLayers == rhs.arrayLayers )
- && ( samples == rhs.samples )
- && ( tiling == rhs.tiling )
- && ( usage == rhs.usage )
- && ( sharingMode == rhs.sharingMode )
- && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
- && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
- && ( initialLayout == rhs.initialLayout );
+ && ( pInheritanceInfo == rhs.pInheritanceInfo );
}
- bool operator!=( ImageCreateInfo const& rhs ) const
+ bool operator!=( CommandBufferBeginInfo const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- ImageCreateFlags flags;
- ImageType imageType;
- Format format;
- Extent3D extent;
- uint32_t mipLevels;
- uint32_t arrayLayers;
- SampleCountFlagBits samples;
- ImageTiling tiling;
- ImageUsageFlags usage;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- ImageLayout initialLayout;
+ CommandBufferUsageFlags flags;
+ const CommandBufferInheritanceInfo* pInheritanceInfo;
};
- static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
- struct PipelineMultisampleStateCreateInfo
+ struct QueryPoolCreateInfo
{
- 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 )
+ QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
+ : sType( StructureType::eQueryPoolCreateInfo )
, pNext( nullptr )
, flags( flags_ )
- , rasterizationSamples( rasterizationSamples_ )
- , sampleShadingEnable( sampleShadingEnable_ )
- , minSampleShading( minSampleShading_ )
- , pSampleMask( pSampleMask_ )
- , alphaToCoverageEnable( alphaToCoverageEnable_ )
- , alphaToOneEnable( alphaToOneEnable_ )
+ , queryType( queryType_ )
+ , queryCount( queryCount_ )
+ , pipelineStatistics( pipelineStatistics_ )
{
}
- PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+ QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
+ memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
}
- PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+ QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
+ memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
return *this;
}
- PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
+ QueryPoolCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
+ QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
- {
- rasterizationSamples = rasterizationSamples_;
- return *this;
- }
-
- PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
- {
- sampleShadingEnable = sampleShadingEnable_;
- return *this;
- }
-
- PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
- {
- minSampleShading = minSampleShading_;
- return *this;
- }
-
- PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
+ QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
{
- pSampleMask = pSampleMask_;
+ queryType = queryType_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+ QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
{
- alphaToCoverageEnable = alphaToCoverageEnable_;
+ queryCount = queryCount_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+ QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
{
- alphaToOneEnable = alphaToOneEnable_;
+ pipelineStatistics = pipelineStatistics_;
return *this;
}
- operator const VkPipelineMultisampleStateCreateInfo&() const
+ operator const VkQueryPoolCreateInfo&() const
{
- return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
+ return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
}
- bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
+ bool operator==( QueryPoolCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( rasterizationSamples == rhs.rasterizationSamples )
- && ( sampleShadingEnable == rhs.sampleShadingEnable )
- && ( minSampleShading == rhs.minSampleShading )
- && ( pSampleMask == rhs.pSampleMask )
- && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
- && ( alphaToOneEnable == rhs.alphaToOneEnable );
+ && ( queryType == rhs.queryType )
+ && ( queryCount == rhs.queryCount )
+ && ( pipelineStatistics == rhs.pipelineStatistics );
}
- bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
+ bool operator!=( QueryPoolCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineMultisampleStateCreateFlags flags;
- SampleCountFlagBits rasterizationSamples;
- Bool32 sampleShadingEnable;
- float minSampleShading;
- const SampleMask* pSampleMask;
- Bool32 alphaToCoverageEnable;
- Bool32 alphaToOneEnable;
+ QueryPoolCreateFlags flags;
+ QueryType queryType;
+ uint32_t queryCount;
+ QueryPipelineStatisticFlags pipelineStatistics;
};
- static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
- struct GraphicsPipelineCreateInfo
+ enum class ImageAspectFlagBits
{
- 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_ )
- , stageCount( stageCount_ )
- , pStages( pStages_ )
- , pVertexInputState( pVertexInputState_ )
- , pInputAssemblyState( pInputAssemblyState_ )
- , pTessellationState( pTessellationState_ )
- , pViewportState( pViewportState_ )
- , pRasterizationState( pRasterizationState_ )
- , pMultisampleState( pMultisampleState_ )
- , pDepthStencilState( pDepthStencilState_ )
- , pColorBlendState( pColorBlendState_ )
- , pDynamicState( pDynamicState_ )
- , layout( layout_ )
- , renderPass( renderPass_ )
- , subpass( subpass_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
- {
- }
+ eColor = VK_IMAGE_ASPECT_COLOR_BIT,
+ eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
+ eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
+ eMetadata = VK_IMAGE_ASPECT_METADATA_BIT
+ };
- GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
+ using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
+
+ VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
+ {
+ return ~( ImageAspectFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ImageAspectFlagBits>
+ {
+ enum
{
- memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
- }
+ allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata)
+ };
+ };
- GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
+ struct ImageSubresource
+ {
+ ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 )
+ : aspectMask( aspectMask_ )
+ , mipLevel( mipLevel_ )
+ , arrayLayer( arrayLayer_ )
{
- memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
- return *this;
}
- GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
+ ImageSubresource( VkImageSubresource const & rhs )
{
- pNext = pNext_;
- return *this;
+ memcpy( this, &rhs, sizeof(ImageSubresource) );
}
- GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
+ ImageSubresource& operator=( VkImageSubresource const & rhs )
{
- flags = flags_;
+ memcpy( this, &rhs, sizeof(ImageSubresource) );
return *this;
}
- GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
+ ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
{
- stageCount = stageCount_;
+ aspectMask = aspectMask_;
return *this;
}
- GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+ ImageSubresource& setMipLevel( uint32_t mipLevel_ )
{
- pStages = pStages_;
+ mipLevel = mipLevel_;
return *this;
}
- GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
+ ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
{
- pVertexInputState = pVertexInputState_;
+ arrayLayer = arrayLayer_;
return *this;
}
- GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+ operator const VkImageSubresource&() const
{
- pInputAssemblyState = pInputAssemblyState_;
- return *this;
+ return *reinterpret_cast<const VkImageSubresource*>(this);
}
- GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+ bool operator==( ImageSubresource const& rhs ) const
{
- pTessellationState = pTessellationState_;
+ return ( aspectMask == rhs.aspectMask )
+ && ( mipLevel == rhs.mipLevel )
+ && ( arrayLayer == rhs.arrayLayer );
+ }
+
+ bool operator!=( ImageSubresource const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t arrayLayer;
+ };
+ static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
+
+ struct ImageSubresourceLayers
+ {
+ ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
+ : aspectMask( aspectMask_ )
+ , mipLevel( mipLevel_ )
+ , baseArrayLayer( baseArrayLayer_ )
+ , layerCount( layerCount_ )
+ {
+ }
+
+ ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
+ }
+
+ ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
return *this;
}
- GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+ ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
{
- pViewportState = pViewportState_;
+ aspectMask = aspectMask_;
return *this;
}
- GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+ ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
{
- pRasterizationState = pRasterizationState_;
+ mipLevel = mipLevel_;
return *this;
}
- GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+ ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
{
- pMultisampleState = pMultisampleState_;
+ baseArrayLayer = baseArrayLayer_;
return *this;
}
- GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+ ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
{
- pDepthStencilState = pDepthStencilState_;
+ layerCount = layerCount_;
return *this;
}
- GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+ operator const VkImageSubresourceLayers&() const
{
- pColorBlendState = pColorBlendState_;
+ return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
+ }
+
+ bool operator==( ImageSubresourceLayers const& rhs ) const
+ {
+ return ( aspectMask == rhs.aspectMask )
+ && ( mipLevel == rhs.mipLevel )
+ && ( baseArrayLayer == rhs.baseArrayLayer )
+ && ( layerCount == rhs.layerCount );
+ }
+
+ bool operator!=( ImageSubresourceLayers const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+ };
+ static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
+
+ struct ImageSubresourceRange
+ {
+ ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
+ : aspectMask( aspectMask_ )
+ , baseMipLevel( baseMipLevel_ )
+ , levelCount( levelCount_ )
+ , baseArrayLayer( baseArrayLayer_ )
+ , layerCount( layerCount_ )
+ {
+ }
+
+ ImageSubresourceRange( VkImageSubresourceRange const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
+ }
+
+ ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
return *this;
}
- GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+ ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
{
- pDynamicState = pDynamicState_;
+ aspectMask = aspectMask_;
return *this;
}
- GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
+ ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
{
- layout = layout_;
+ baseMipLevel = baseMipLevel_;
return *this;
}
- GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
+ ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
{
- renderPass = renderPass_;
+ levelCount = levelCount_;
return *this;
}
- GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
+ ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
{
- subpass = subpass_;
+ baseArrayLayer = baseArrayLayer_;
return *this;
}
- GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
{
- basePipelineHandle = basePipelineHandle_;
+ layerCount = layerCount_;
return *this;
}
- GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
+ operator const VkImageSubresourceRange&() const
{
- basePipelineIndex = basePipelineIndex_;
+ return *reinterpret_cast<const VkImageSubresourceRange*>(this);
+ }
+
+ bool operator==( ImageSubresourceRange const& rhs ) const
+ {
+ return ( aspectMask == rhs.aspectMask )
+ && ( baseMipLevel == rhs.baseMipLevel )
+ && ( levelCount == rhs.levelCount )
+ && ( baseArrayLayer == rhs.baseArrayLayer )
+ && ( layerCount == rhs.layerCount );
+ }
+
+ bool operator!=( ImageSubresourceRange const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t baseMipLevel;
+ uint32_t levelCount;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+ };
+ static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
+
+ 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_ )
+ , dstAccessMask( dstAccessMask_ )
+ , oldLayout( oldLayout_ )
+ , newLayout( newLayout_ )
+ , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+ , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+ , image( image_ )
+ , subresourceRange( subresourceRange_ )
+ {
+ }
+
+ ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
+ }
+
+ ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
return *this;
}
- operator const VkGraphicsPipelineCreateInfo&() const
+ ImageMemoryBarrier& setPNext( const void* pNext_ )
{
- return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
+ pNext = pNext_;
+ return *this;
}
- bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
+ ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ {
+ srcAccessMask = srcAccessMask_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ {
+ dstAccessMask = dstAccessMask_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
+ {
+ oldLayout = oldLayout_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
+ {
+ newLayout = newLayout_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+ {
+ srcQueueFamilyIndex = srcQueueFamilyIndex_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+ {
+ dstQueueFamilyIndex = dstQueueFamilyIndex_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ {
+ subresourceRange = subresourceRange_;
+ return *this;
+ }
+
+ operator const VkImageMemoryBarrier&() const
+ {
+ return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
+ }
+
+ bool operator==( ImageMemoryBarrier const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( stageCount == rhs.stageCount )
- && ( pStages == rhs.pStages )
- && ( pVertexInputState == rhs.pVertexInputState )
- && ( pInputAssemblyState == rhs.pInputAssemblyState )
- && ( pTessellationState == rhs.pTessellationState )
- && ( pViewportState == rhs.pViewportState )
- && ( pRasterizationState == rhs.pRasterizationState )
- && ( pMultisampleState == rhs.pMultisampleState )
- && ( pDepthStencilState == rhs.pDepthStencilState )
- && ( pColorBlendState == rhs.pColorBlendState )
- && ( pDynamicState == rhs.pDynamicState )
- && ( layout == rhs.layout )
- && ( renderPass == rhs.renderPass )
- && ( subpass == rhs.subpass )
- && ( basePipelineHandle == rhs.basePipelineHandle )
- && ( basePipelineIndex == rhs.basePipelineIndex );
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( oldLayout == rhs.oldLayout )
+ && ( newLayout == rhs.newLayout )
+ && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
+ && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
+ && ( image == rhs.image )
+ && ( subresourceRange == rhs.subresourceRange );
}
- bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
+ bool operator!=( ImageMemoryBarrier const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineCreateFlags flags;
- uint32_t stageCount;
- const PipelineShaderStageCreateInfo* pStages;
- const PipelineVertexInputStateCreateInfo* pVertexInputState;
- const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
- const PipelineTessellationStateCreateInfo* pTessellationState;
- const PipelineViewportStateCreateInfo* pViewportState;
- const PipelineRasterizationStateCreateInfo* pRasterizationState;
- const PipelineMultisampleStateCreateInfo* pMultisampleState;
- const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
- const PipelineColorBlendStateCreateInfo* pColorBlendState;
- const PipelineDynamicStateCreateInfo* pDynamicState;
- PipelineLayout layout;
- RenderPass renderPass;
- uint32_t subpass;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ ImageLayout oldLayout;
+ ImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ Image image;
+ ImageSubresourceRange subresourceRange;
};
- static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
- struct PhysicalDeviceLimits
+ struct ImageViewCreateInfo
{
- operator const VkPhysicalDeviceLimits&() const
+ 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_ )
+ , image( image_ )
+ , viewType( viewType_ )
+ , format( format_ )
+ , components( components_ )
+ , subresourceRange( subresourceRange_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
}
- bool operator==( PhysicalDeviceLimits const& rhs ) const
+ ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
{
- return ( maxImageDimension1D == rhs.maxImageDimension1D )
- && ( maxImageDimension2D == rhs.maxImageDimension2D )
- && ( maxImageDimension3D == rhs.maxImageDimension3D )
- && ( maxImageDimensionCube == rhs.maxImageDimensionCube )
- && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
- && ( maxTexelBufferElements == rhs.maxTexelBufferElements )
- && ( maxUniformBufferRange == rhs.maxUniformBufferRange )
- && ( maxStorageBufferRange == rhs.maxStorageBufferRange )
- && ( maxPushConstantsSize == rhs.maxPushConstantsSize )
- && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount )
- && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount )
- && ( bufferImageGranularity == rhs.bufferImageGranularity )
- && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize )
- && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets )
- && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers )
- && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers )
- && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers )
- && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages )
- && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages )
- && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments )
- && ( maxPerStageResources == rhs.maxPerStageResources )
- && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers )
- && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers )
- && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic )
- && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers )
- && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic )
- && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages )
- && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages )
- && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments )
- && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes )
- && ( maxVertexInputBindings == rhs.maxVertexInputBindings )
- && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset )
- && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride )
- && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents )
- && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel )
- && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize )
- && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents )
- && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents )
- && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents )
- && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents )
- && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents )
- && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents )
- && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations )
- && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents )
- && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents )
- && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices )
- && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents )
- && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents )
- && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments )
- && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
- && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
- && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
- && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
- && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
- && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
- && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
- && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
- && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
- && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue )
- && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount )
- && ( maxSamplerLodBias == rhs.maxSamplerLodBias )
- && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy )
- && ( maxViewports == rhs.maxViewports )
- && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
- && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
- && ( viewportSubPixelBits == rhs.viewportSubPixelBits )
- && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
- && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
- && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment )
- && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment )
- && ( minTexelOffset == rhs.minTexelOffset )
- && ( maxTexelOffset == rhs.maxTexelOffset )
- && ( minTexelGatherOffset == rhs.minTexelGatherOffset )
- && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset )
- && ( minInterpolationOffset == rhs.minInterpolationOffset )
- && ( maxInterpolationOffset == rhs.maxInterpolationOffset )
- && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits )
- && ( maxFramebufferWidth == rhs.maxFramebufferWidth )
- && ( maxFramebufferHeight == rhs.maxFramebufferHeight )
- && ( maxFramebufferLayers == rhs.maxFramebufferLayers )
- && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts )
- && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts )
- && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts )
- && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts )
- && ( maxColorAttachments == rhs.maxColorAttachments )
- && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts )
- && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts )
- && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts )
- && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts )
- && ( storageImageSampleCounts == rhs.storageImageSampleCounts )
- && ( maxSampleMaskWords == rhs.maxSampleMaskWords )
- && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics )
- && ( timestampPeriod == rhs.timestampPeriod )
- && ( maxClipDistances == rhs.maxClipDistances )
- && ( maxCullDistances == rhs.maxCullDistances )
- && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances )
- && ( discreteQueuePriorities == rhs.discreteQueuePriorities )
- && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
- && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
- && ( pointSizeGranularity == rhs.pointSizeGranularity )
- && ( lineWidthGranularity == rhs.lineWidthGranularity )
- && ( strictLines == rhs.strictLines )
- && ( standardSampleLocations == rhs.standardSampleLocations )
- && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment )
- && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment )
- && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+ memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
}
- bool operator!=( PhysicalDeviceLimits const& rhs ) const
+ ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
+ return *this;
+ }
+
+ ImageViewCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
+ {
+ viewType = viewType_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setComponents( ComponentMapping components_ )
+ {
+ components = components_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ {
+ subresourceRange = subresourceRange_;
+ return *this;
+ }
+
+ operator const VkImageViewCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
+ }
+
+ bool operator==( ImageViewCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( image == rhs.image )
+ && ( viewType == rhs.viewType )
+ && ( format == rhs.format )
+ && ( components == rhs.components )
+ && ( subresourceRange == rhs.subresourceRange );
+ }
+
+ bool operator!=( ImageViewCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t maxImageDimension1D;
- uint32_t maxImageDimension2D;
- uint32_t maxImageDimension3D;
- uint32_t maxImageDimensionCube;
- uint32_t maxImageArrayLayers;
- uint32_t maxTexelBufferElements;
- uint32_t maxUniformBufferRange;
- uint32_t maxStorageBufferRange;
- uint32_t maxPushConstantsSize;
- uint32_t maxMemoryAllocationCount;
- uint32_t maxSamplerAllocationCount;
- DeviceSize bufferImageGranularity;
- DeviceSize sparseAddressSpaceSize;
- uint32_t maxBoundDescriptorSets;
- uint32_t maxPerStageDescriptorSamplers;
- uint32_t maxPerStageDescriptorUniformBuffers;
- uint32_t maxPerStageDescriptorStorageBuffers;
- uint32_t maxPerStageDescriptorSampledImages;
- uint32_t maxPerStageDescriptorStorageImages;
- uint32_t maxPerStageDescriptorInputAttachments;
- uint32_t maxPerStageResources;
- uint32_t maxDescriptorSetSamplers;
- uint32_t maxDescriptorSetUniformBuffers;
- uint32_t maxDescriptorSetUniformBuffersDynamic;
- uint32_t maxDescriptorSetStorageBuffers;
- uint32_t maxDescriptorSetStorageBuffersDynamic;
- uint32_t maxDescriptorSetSampledImages;
- uint32_t maxDescriptorSetStorageImages;
- uint32_t maxDescriptorSetInputAttachments;
- uint32_t maxVertexInputAttributes;
- uint32_t maxVertexInputBindings;
- uint32_t maxVertexInputAttributeOffset;
- uint32_t maxVertexInputBindingStride;
- uint32_t maxVertexOutputComponents;
- uint32_t maxTessellationGenerationLevel;
- uint32_t maxTessellationPatchSize;
- uint32_t maxTessellationControlPerVertexInputComponents;
- uint32_t maxTessellationControlPerVertexOutputComponents;
- uint32_t maxTessellationControlPerPatchOutputComponents;
- uint32_t maxTessellationControlTotalOutputComponents;
- uint32_t maxTessellationEvaluationInputComponents;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ ImageViewCreateFlags flags;
+ Image image;
+ ImageViewType viewType;
+ Format format;
+ ComponentMapping components;
+ ImageSubresourceRange subresourceRange;
+ };
+ static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
+
+ struct ImageCopy
+ {
+ ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
+ : srcSubresource( srcSubresource_ )
+ , srcOffset( srcOffset_ )
+ , dstSubresource( dstSubresource_ )
+ , dstOffset( dstOffset_ )
+ , extent( extent_ )
+ {
+ }
+
+ ImageCopy( VkImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageCopy) );
+ }
+
+ ImageCopy& operator=( VkImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageCopy) );
+ return *this;
+ }
+
+ ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ {
+ srcSubresource = srcSubresource_;
+ return *this;
+ }
+
+ ImageCopy& setSrcOffset( Offset3D srcOffset_ )
+ {
+ srcOffset = srcOffset_;
+ return *this;
+ }
+
+ ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ {
+ dstSubresource = dstSubresource_;
+ return *this;
+ }
+
+ ImageCopy& setDstOffset( Offset3D dstOffset_ )
+ {
+ dstOffset = dstOffset_;
+ return *this;
+ }
+
+ ImageCopy& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ operator const VkImageCopy&() const
+ {
+ return *reinterpret_cast<const VkImageCopy*>(this);
+ }
+
+ bool operator==( ImageCopy const& rhs ) const
+ {
+ return ( srcSubresource == rhs.srcSubresource )
+ && ( srcOffset == rhs.srcOffset )
+ && ( dstSubresource == rhs.dstSubresource )
+ && ( dstOffset == rhs.dstOffset )
+ && ( extent == rhs.extent );
+ }
+
+ bool operator!=( ImageCopy const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresourceLayers srcSubresource;
+ Offset3D srcOffset;
+ ImageSubresourceLayers dstSubresource;
+ Offset3D dstOffset;
+ Extent3D extent;
+ };
+ static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
+
+ struct ImageBlit
+ {
+ ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
+ : srcSubresource( srcSubresource_ )
+ , dstSubresource( dstSubresource_ )
+ {
+ memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+ memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ }
+
+ ImageBlit( VkImageBlit const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageBlit) );
+ }
+
+ ImageBlit& operator=( VkImageBlit const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageBlit) );
+ return *this;
+ }
+
+ ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ {
+ srcSubresource = srcSubresource_;
+ return *this;
+ }
+
+ ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+ {
+ memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+ return *this;
+ }
+
+ ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ {
+ dstSubresource = dstSubresource_;
+ return *this;
+ }
+
+ ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+ {
+ memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ return *this;
+ }
+
+ operator const VkImageBlit&() const
+ {
+ return *reinterpret_cast<const VkImageBlit*>(this);
+ }
+
+ bool operator==( ImageBlit const& rhs ) const
+ {
+ return ( srcSubresource == rhs.srcSubresource )
+ && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
+ && ( dstSubresource == rhs.dstSubresource )
+ && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+ }
+
+ bool operator!=( ImageBlit const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresourceLayers srcSubresource;
+ Offset3D srcOffsets[2];
+ ImageSubresourceLayers dstSubresource;
+ Offset3D dstOffsets[2];
+ };
+ static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
+
+ struct BufferImageCopy
+ {
+ BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() )
+ : bufferOffset( bufferOffset_ )
+ , bufferRowLength( bufferRowLength_ )
+ , bufferImageHeight( bufferImageHeight_ )
+ , imageSubresource( imageSubresource_ )
+ , imageOffset( imageOffset_ )
+ , imageExtent( imageExtent_ )
+ {
+ }
+
+ BufferImageCopy( VkBufferImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(BufferImageCopy) );
+ }
+
+ BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(BufferImageCopy) );
+ return *this;
+ }
+
+ BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
+ {
+ bufferOffset = bufferOffset_;
+ return *this;
+ }
+
+ BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
+ {
+ bufferRowLength = bufferRowLength_;
+ return *this;
+ }
+
+ BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
+ {
+ bufferImageHeight = bufferImageHeight_;
+ return *this;
+ }
+
+ BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+ {
+ imageSubresource = imageSubresource_;
+ return *this;
+ }
+
+ BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
+ {
+ imageOffset = imageOffset_;
+ return *this;
+ }
+
+ BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
+ {
+ imageExtent = imageExtent_;
+ return *this;
+ }
+
+ operator const VkBufferImageCopy&() const
+ {
+ return *reinterpret_cast<const VkBufferImageCopy*>(this);
+ }
+
+ bool operator==( BufferImageCopy const& rhs ) const
+ {
+ return ( bufferOffset == rhs.bufferOffset )
+ && ( bufferRowLength == rhs.bufferRowLength )
+ && ( bufferImageHeight == rhs.bufferImageHeight )
+ && ( imageSubresource == rhs.imageSubresource )
+ && ( imageOffset == rhs.imageOffset )
+ && ( imageExtent == rhs.imageExtent );
+ }
+
+ bool operator!=( BufferImageCopy const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DeviceSize bufferOffset;
+ uint32_t bufferRowLength;
+ uint32_t bufferImageHeight;
+ ImageSubresourceLayers imageSubresource;
+ Offset3D imageOffset;
+ Extent3D imageExtent;
+ };
+ static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
+
+ struct ImageResolve
+ {
+ ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
+ : srcSubresource( srcSubresource_ )
+ , srcOffset( srcOffset_ )
+ , dstSubresource( dstSubresource_ )
+ , dstOffset( dstOffset_ )
+ , extent( extent_ )
+ {
+ }
+
+ ImageResolve( VkImageResolve const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageResolve) );
+ }
+
+ ImageResolve& operator=( VkImageResolve const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageResolve) );
+ return *this;
+ }
+
+ ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ {
+ srcSubresource = srcSubresource_;
+ return *this;
+ }
+
+ ImageResolve& setSrcOffset( Offset3D srcOffset_ )
+ {
+ srcOffset = srcOffset_;
+ return *this;
+ }
+
+ ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ {
+ dstSubresource = dstSubresource_;
+ return *this;
+ }
+
+ ImageResolve& setDstOffset( Offset3D dstOffset_ )
+ {
+ dstOffset = dstOffset_;
+ return *this;
+ }
+
+ ImageResolve& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ operator const VkImageResolve&() const
+ {
+ return *reinterpret_cast<const VkImageResolve*>(this);
+ }
+
+ bool operator==( ImageResolve const& rhs ) const
+ {
+ return ( srcSubresource == rhs.srcSubresource )
+ && ( srcOffset == rhs.srcOffset )
+ && ( dstSubresource == rhs.dstSubresource )
+ && ( dstOffset == rhs.dstOffset )
+ && ( extent == rhs.extent );
+ }
+
+ bool operator!=( ImageResolve const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresourceLayers srcSubresource;
+ Offset3D srcOffset;
+ ImageSubresourceLayers dstSubresource;
+ Offset3D dstOffset;
+ Extent3D extent;
+ };
+ static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
+
+ struct ClearAttachment
+ {
+ ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() )
+ : aspectMask( aspectMask_ )
+ , colorAttachment( colorAttachment_ )
+ , clearValue( clearValue_ )
+ {
+ }
+
+ ClearAttachment( VkClearAttachment const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ClearAttachment) );
+ }
+
+ ClearAttachment& operator=( VkClearAttachment const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ClearAttachment) );
+ return *this;
+ }
+
+ ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
+ {
+ aspectMask = aspectMask_;
+ return *this;
+ }
+
+ ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
+ {
+ colorAttachment = colorAttachment_;
+ return *this;
+ }
+
+ ClearAttachment& setClearValue( ClearValue clearValue_ )
+ {
+ clearValue = clearValue_;
+ return *this;
+ }
+
+ operator const VkClearAttachment&() const
+ {
+ return *reinterpret_cast<const VkClearAttachment*>(this);
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t colorAttachment;
+ ClearValue clearValue;
+ };
+ static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
+
+ enum class SparseImageFormatFlagBits
+ {
+ eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
+ eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
+ eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
+ };
+
+ using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
+
+ VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
+ {
+ return ~( SparseImageFormatFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SparseImageFormatFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
+ };
+ };
+
+ struct SparseImageFormatProperties
+ {
+ operator const VkSparseImageFormatProperties&() const
+ {
+ return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
+ }
+
+ bool operator==( SparseImageFormatProperties const& rhs ) const
+ {
+ return ( aspectMask == rhs.aspectMask )
+ && ( imageGranularity == rhs.imageGranularity )
+ && ( flags == rhs.flags );
+ }
+
+ bool operator!=( SparseImageFormatProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ Extent3D imageGranularity;
+ SparseImageFormatFlags flags;
+ };
+ static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
+
+ struct SparseImageMemoryRequirements
+ {
+ operator const VkSparseImageMemoryRequirements&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
+ }
+
+ bool operator==( SparseImageMemoryRequirements const& rhs ) const
+ {
+ return ( formatProperties == rhs.formatProperties )
+ && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
+ && ( imageMipTailSize == rhs.imageMipTailSize )
+ && ( imageMipTailOffset == rhs.imageMipTailOffset )
+ && ( imageMipTailStride == rhs.imageMipTailStride );
+ }
+
+ bool operator!=( SparseImageMemoryRequirements const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ SparseImageFormatProperties formatProperties;
+ uint32_t imageMipTailFirstLod;
+ DeviceSize imageMipTailSize;
+ DeviceSize imageMipTailOffset;
+ DeviceSize imageMipTailStride;
+ };
+ static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
+
+ struct SparseImageFormatProperties2KHR
+ {
+ operator const VkSparseImageFormatProperties2KHR&() const
+ {
+ return *reinterpret_cast<const VkSparseImageFormatProperties2KHR*>(this);
+ }
+
+ bool operator==( SparseImageFormatProperties2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( properties == rhs.properties );
+ }
+
+ bool operator!=( SparseImageFormatProperties2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ SparseImageFormatProperties properties;
+ };
+ static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" );
+
+ enum class SparseMemoryBindFlagBits
+ {
+ eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
+ };
+
+ using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
+
+ VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
+ {
+ return ~( SparseMemoryBindFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SparseMemoryBindFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
+ };
+ };
+
+ struct SparseMemoryBind
+ {
+ SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+ : resourceOffset( resourceOffset_ )
+ , size( size_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , flags( flags_ )
+ {
+ }
+
+ SparseMemoryBind( VkSparseMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseMemoryBind) );
+ }
+
+ SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseMemoryBind) );
+ return *this;
+ }
+
+ SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
+ {
+ resourceOffset = resourceOffset_;
+ return *this;
+ }
+
+ SparseMemoryBind& setSize( DeviceSize size_ )
+ {
+ size = size_;
+ return *this;
+ }
+
+ SparseMemoryBind& setMemory( DeviceMemory memory_ )
+ {
+ memory = memory_;
+ return *this;
+ }
+
+ SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ {
+ memoryOffset = memoryOffset_;
+ return *this;
+ }
+
+ SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ operator const VkSparseMemoryBind&() const
+ {
+ return *reinterpret_cast<const VkSparseMemoryBind*>(this);
+ }
+
+ bool operator==( SparseMemoryBind const& rhs ) const
+ {
+ return ( resourceOffset == rhs.resourceOffset )
+ && ( size == rhs.size )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( flags == rhs.flags );
+ }
+
+ bool operator!=( SparseMemoryBind const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DeviceSize resourceOffset;
+ DeviceSize size;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ SparseMemoryBindFlags flags;
+ };
+ static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
+
+ struct SparseImageMemoryBind
+ {
+ SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+ : subresource( subresource_ )
+ , offset( offset_ )
+ , extent( extent_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , flags( flags_ )
+ {
+ }
+
+ SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
+ }
+
+ SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
+ return *this;
+ }
+
+ SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
+ {
+ subresource = subresource_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setOffset( Offset3D offset_ )
+ {
+ offset = offset_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
+ {
+ memory = memory_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ {
+ memoryOffset = memoryOffset_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ operator const VkSparseImageMemoryBind&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
+ }
+
+ bool operator==( SparseImageMemoryBind const& rhs ) const
+ {
+ return ( subresource == rhs.subresource )
+ && ( offset == rhs.offset )
+ && ( extent == rhs.extent )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( flags == rhs.flags );
+ }
+
+ bool operator!=( SparseImageMemoryBind const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresource subresource;
+ Offset3D offset;
+ Extent3D extent;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ SparseMemoryBindFlags flags;
+ };
+ static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
+
+ struct SparseBufferMemoryBindInfo
+ {
+ SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
+ : buffer( buffer_ )
+ , bindCount( bindCount_ )
+ , pBinds( pBinds_ )
+ {
+ }
+
+ SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
+ }
+
+ SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
+ return *this;
+ }
+
+ SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
+ {
+ buffer = buffer_;
+ return *this;
+ }
+
+ SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ {
+ bindCount = bindCount_;
+ return *this;
+ }
+
+ SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ {
+ pBinds = pBinds_;
+ return *this;
+ }
+
+ operator const VkSparseBufferMemoryBindInfo&() const
+ {
+ return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
+ }
+
+ bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
+ {
+ return ( buffer == rhs.buffer )
+ && ( bindCount == rhs.bindCount )
+ && ( pBinds == rhs.pBinds );
+ }
+
+ bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Buffer buffer;
+ uint32_t bindCount;
+ const SparseMemoryBind* pBinds;
+ };
+ static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
+
+ struct SparseImageOpaqueMemoryBindInfo
+ {
+ SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
+ : image( image_ )
+ , bindCount( bindCount_ )
+ , pBinds( pBinds_ )
+ {
+ }
+
+ SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
+ }
+
+ SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
+ return *this;
+ }
+
+ SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ {
+ bindCount = bindCount_;
+ return *this;
+ }
+
+ SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ {
+ pBinds = pBinds_;
+ return *this;
+ }
+
+ operator const VkSparseImageOpaqueMemoryBindInfo&() const
+ {
+ return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
+ }
+
+ bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ {
+ return ( image == rhs.image )
+ && ( bindCount == rhs.bindCount )
+ && ( pBinds == rhs.pBinds );
+ }
+
+ bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Image image;
+ uint32_t bindCount;
+ const SparseMemoryBind* pBinds;
+ };
+ static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
+
+ struct SparseImageMemoryBindInfo
+ {
+ SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr )
+ : image( image_ )
+ , bindCount( bindCount_ )
+ , pBinds( pBinds_ )
+ {
+ }
+
+ SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
+ }
+
+ SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
+ return *this;
+ }
+
+ SparseImageMemoryBindInfo& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ {
+ bindCount = bindCount_;
+ return *this;
+ }
+
+ SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
+ {
+ pBinds = pBinds_;
+ return *this;
+ }
+
+ operator const VkSparseImageMemoryBindInfo&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
+ }
+
+ bool operator==( SparseImageMemoryBindInfo const& rhs ) const
+ {
+ return ( image == rhs.image )
+ && ( bindCount == rhs.bindCount )
+ && ( pBinds == rhs.pBinds );
+ }
+
+ bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Image image;
+ uint32_t bindCount;
+ const SparseImageMemoryBind* pBinds;
+ };
+ static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "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_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , bufferBindCount( bufferBindCount_ )
+ , pBufferBinds( pBufferBinds_ )
+ , imageOpaqueBindCount( imageOpaqueBindCount_ )
+ , pImageOpaqueBinds( pImageOpaqueBinds_ )
+ , imageBindCount( imageBindCount_ )
+ , pImageBinds( pImageBinds_ )
+ , signalSemaphoreCount( signalSemaphoreCount_ )
+ , pSignalSemaphores( pSignalSemaphores_ )
+ {
+ }
+
+ BindSparseInfo( VkBindSparseInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(BindSparseInfo) );
+ }
+
+ BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(BindSparseInfo) );
+ return *this;
+ }
+
+ BindSparseInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ {
+ waitSemaphoreCount = waitSemaphoreCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ {
+ pWaitSemaphores = pWaitSemaphores_;
+ return *this;
+ }
+
+ BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
+ {
+ bufferBindCount = bufferBindCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+ {
+ pBufferBinds = pBufferBinds_;
+ return *this;
+ }
+
+ BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
+ {
+ imageOpaqueBindCount = imageOpaqueBindCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+ {
+ pImageOpaqueBinds = pImageOpaqueBinds_;
+ return *this;
+ }
+
+ BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
+ {
+ imageBindCount = imageBindCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+ {
+ pImageBinds = pImageBinds_;
+ return *this;
+ }
+
+ BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+ {
+ signalSemaphoreCount = signalSemaphoreCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+ {
+ pSignalSemaphores = pSignalSemaphores_;
+ return *this;
+ }
+
+ operator const VkBindSparseInfo&() const
+ {
+ return *reinterpret_cast<const VkBindSparseInfo*>(this);
+ }
+
+ bool operator==( BindSparseInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+ && ( pWaitSemaphores == rhs.pWaitSemaphores )
+ && ( bufferBindCount == rhs.bufferBindCount )
+ && ( pBufferBinds == rhs.pBufferBinds )
+ && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
+ && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
+ && ( imageBindCount == rhs.imageBindCount )
+ && ( pImageBinds == rhs.pImageBinds )
+ && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
+ && ( pSignalSemaphores == rhs.pSignalSemaphores );
+ }
+
+ bool operator!=( BindSparseInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ const Semaphore* pWaitSemaphores;
+ uint32_t bufferBindCount;
+ const SparseBufferMemoryBindInfo* pBufferBinds;
+ uint32_t imageOpaqueBindCount;
+ const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+ uint32_t imageBindCount;
+ const SparseImageMemoryBindInfo* pImageBinds;
+ uint32_t signalSemaphoreCount;
+ const Semaphore* pSignalSemaphores;
+ };
+ static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
+
+ enum class PipelineStageFlagBits
+ {
+ eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
+ eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+ eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+ eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
+ eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
+ eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+ eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+ eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+ eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+ eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+ eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+ eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
+ eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+ eHost = VK_PIPELINE_STAGE_HOST_BIT,
+ eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+ eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
+ };
+
+ using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
+
+ VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
+ {
+ return ~( PipelineStageFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<PipelineStageFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX)
+ };
+ };
+
+ enum class CommandPoolCreateFlagBits
+ {
+ eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
+ eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
+ };
+
+ using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
+
+ VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
+ {
+ return ~( CommandPoolCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandPoolCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer)
+ };
+ };
+
+ struct CommandPoolCreateInfo
+ {
+ CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 )
+ : sType( StructureType::eCommandPoolCreateInfo )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ {
+ }
+
+ CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
+ }
+
+ CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
+ return *this;
+ }
+
+ CommandPoolCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+ {
+ queueFamilyIndex = queueFamilyIndex_;
+ return *this;
+ }
+
+ operator const VkCommandPoolCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
+ }
+
+ bool operator==( CommandPoolCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( queueFamilyIndex == rhs.queueFamilyIndex );
+ }
+
+ bool operator!=( CommandPoolCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ CommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ };
+ static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
+
+ enum class CommandPoolResetFlagBits
+ {
+ eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
+ };
+
+ using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
+
+ VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
+ {
+ return ~( CommandPoolResetFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandPoolResetFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
+ };
+ };
+
+ enum class CommandBufferResetFlagBits
+ {
+ eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+ };
+
+ using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
+
+ VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+ {
+ return ~( CommandBufferResetFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandBufferResetFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
+ };
+ };
+
+ enum class SampleCountFlagBits
+ {
+ e1 = VK_SAMPLE_COUNT_1_BIT,
+ e2 = VK_SAMPLE_COUNT_2_BIT,
+ e4 = VK_SAMPLE_COUNT_4_BIT,
+ e8 = VK_SAMPLE_COUNT_8_BIT,
+ e16 = VK_SAMPLE_COUNT_16_BIT,
+ e32 = VK_SAMPLE_COUNT_32_BIT,
+ e64 = VK_SAMPLE_COUNT_64_BIT
+ };
+
+ using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
+
+ VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
+ {
+ return ~( SampleCountFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SampleCountFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
+ };
+ };
+
+ struct ImageFormatProperties
+ {
+ operator const VkImageFormatProperties&() const
+ {
+ return *reinterpret_cast<const VkImageFormatProperties*>(this);
+ }
+
+ bool operator==( ImageFormatProperties const& rhs ) const
+ {
+ return ( maxExtent == rhs.maxExtent )
+ && ( maxMipLevels == rhs.maxMipLevels )
+ && ( maxArrayLayers == rhs.maxArrayLayers )
+ && ( sampleCounts == rhs.sampleCounts )
+ && ( maxResourceSize == rhs.maxResourceSize );
+ }
+
+ bool operator!=( ImageFormatProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Extent3D maxExtent;
+ uint32_t maxMipLevels;
+ uint32_t maxArrayLayers;
+ SampleCountFlags sampleCounts;
+ DeviceSize maxResourceSize;
+ };
+ static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
+
+ 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_ )
+ , imageType( imageType_ )
+ , format( format_ )
+ , extent( extent_ )
+ , mipLevels( mipLevels_ )
+ , arrayLayers( arrayLayers_ )
+ , samples( samples_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , initialLayout( initialLayout_ )
+ {
+ }
+
+ ImageCreateInfo( VkImageCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageCreateInfo) );
+ }
+
+ ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImageCreateInfo) );
+ return *this;
+ }
+
+ ImageCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ImageCreateInfo& setImageType( ImageType imageType_ )
+ {
+ imageType = imageType_;
+ return *this;
+ }
+
+ ImageCreateInfo& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ ImageCreateInfo& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
+ {
+ mipLevels = mipLevels_;
+ return *this;
+ }
+
+ ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
+ {
+ arrayLayers = arrayLayers_;
+ return *this;
+ }
+
+ ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ ImageCreateInfo& setTiling( ImageTiling tiling_ )
+ {
+ tiling = tiling_;
+ return *this;
+ }
+
+ ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
+ {
+ sharingMode = sharingMode_;
+ return *this;
+ }
+
+ ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ {
+ queueFamilyIndexCount = queueFamilyIndexCount_;
+ return *this;
+ }
+
+ ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ {
+ pQueueFamilyIndices = pQueueFamilyIndices_;
+ return *this;
+ }
+
+ ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
+ {
+ initialLayout = initialLayout_;
+ return *this;
+ }
+
+ operator const VkImageCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkImageCreateInfo*>(this);
+ }
+
+ bool operator==( ImageCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( imageType == rhs.imageType )
+ && ( format == rhs.format )
+ && ( extent == rhs.extent )
+ && ( mipLevels == rhs.mipLevels )
+ && ( arrayLayers == rhs.arrayLayers )
+ && ( samples == rhs.samples )
+ && ( tiling == rhs.tiling )
+ && ( usage == rhs.usage )
+ && ( sharingMode == rhs.sharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
+ && ( initialLayout == rhs.initialLayout );
+ }
+
+ bool operator!=( ImageCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ ImageCreateFlags flags;
+ ImageType imageType;
+ Format format;
+ Extent3D extent;
+ uint32_t mipLevels;
+ uint32_t arrayLayers;
+ SampleCountFlagBits samples;
+ ImageTiling tiling;
+ ImageUsageFlags usage;
+ SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ ImageLayout initialLayout;
+ };
+ static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
+
+ 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_ )
+ , rasterizationSamples( rasterizationSamples_ )
+ , sampleShadingEnable( sampleShadingEnable_ )
+ , minSampleShading( minSampleShading_ )
+ , pSampleMask( pSampleMask_ )
+ , alphaToCoverageEnable( alphaToCoverageEnable_ )
+ , alphaToOneEnable( alphaToOneEnable_ )
+ {
+ }
+
+ PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
+ }
+
+ PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
+ {
+ rasterizationSamples = rasterizationSamples_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
+ {
+ sampleShadingEnable = sampleShadingEnable_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
+ {
+ minSampleShading = minSampleShading_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
+ {
+ pSampleMask = pSampleMask_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+ {
+ alphaToCoverageEnable = alphaToCoverageEnable_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+ {
+ alphaToOneEnable = alphaToOneEnable_;
+ return *this;
+ }
+
+ operator const VkPipelineMultisampleStateCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
+ }
+
+ bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( rasterizationSamples == rhs.rasterizationSamples )
+ && ( sampleShadingEnable == rhs.sampleShadingEnable )
+ && ( minSampleShading == rhs.minSampleShading )
+ && ( pSampleMask == rhs.pSampleMask )
+ && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
+ && ( alphaToOneEnable == rhs.alphaToOneEnable );
+ }
+
+ bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ PipelineMultisampleStateCreateFlags flags;
+ SampleCountFlagBits rasterizationSamples;
+ Bool32 sampleShadingEnable;
+ float minSampleShading;
+ const SampleMask* pSampleMask;
+ Bool32 alphaToCoverageEnable;
+ Bool32 alphaToOneEnable;
+ };
+ static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
+
+ 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_ )
+ , stageCount( stageCount_ )
+ , pStages( pStages_ )
+ , pVertexInputState( pVertexInputState_ )
+ , pInputAssemblyState( pInputAssemblyState_ )
+ , pTessellationState( pTessellationState_ )
+ , pViewportState( pViewportState_ )
+ , pRasterizationState( pRasterizationState_ )
+ , pMultisampleState( pMultisampleState_ )
+ , pDepthStencilState( pDepthStencilState_ )
+ , pColorBlendState( pColorBlendState_ )
+ , pDynamicState( pDynamicState_ )
+ , layout( layout_ )
+ , renderPass( renderPass_ )
+ , subpass( subpass_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
+ {
+ }
+
+ GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
+ }
+
+ GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
+ {
+ stageCount = stageCount_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+ {
+ pStages = pStages_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
+ {
+ pVertexInputState = pVertexInputState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+ {
+ pInputAssemblyState = pInputAssemblyState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+ {
+ pTessellationState = pTessellationState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+ {
+ pViewportState = pViewportState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+ {
+ pRasterizationState = pRasterizationState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+ {
+ pMultisampleState = pMultisampleState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+ {
+ pDepthStencilState = pDepthStencilState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+ {
+ pColorBlendState = pColorBlendState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+ {
+ pDynamicState = pDynamicState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
+ {
+ layout = layout_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
+ {
+ renderPass = renderPass_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
+ {
+ subpass = subpass_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ {
+ basePipelineHandle = basePipelineHandle_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
+ {
+ basePipelineIndex = basePipelineIndex_;
+ return *this;
+ }
+
+ operator const VkGraphicsPipelineCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
+ }
+
+ bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( stageCount == rhs.stageCount )
+ && ( pStages == rhs.pStages )
+ && ( pVertexInputState == rhs.pVertexInputState )
+ && ( pInputAssemblyState == rhs.pInputAssemblyState )
+ && ( pTessellationState == rhs.pTessellationState )
+ && ( pViewportState == rhs.pViewportState )
+ && ( pRasterizationState == rhs.pRasterizationState )
+ && ( pMultisampleState == rhs.pMultisampleState )
+ && ( pDepthStencilState == rhs.pDepthStencilState )
+ && ( pColorBlendState == rhs.pColorBlendState )
+ && ( pDynamicState == rhs.pDynamicState )
+ && ( layout == rhs.layout )
+ && ( renderPass == rhs.renderPass )
+ && ( subpass == rhs.subpass )
+ && ( basePipelineHandle == rhs.basePipelineHandle )
+ && ( basePipelineIndex == rhs.basePipelineIndex );
+ }
+
+ bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ PipelineCreateFlags flags;
+ uint32_t stageCount;
+ const PipelineShaderStageCreateInfo* pStages;
+ const PipelineVertexInputStateCreateInfo* pVertexInputState;
+ const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ const PipelineTessellationStateCreateInfo* pTessellationState;
+ const PipelineViewportStateCreateInfo* pViewportState;
+ const PipelineRasterizationStateCreateInfo* pRasterizationState;
+ const PipelineMultisampleStateCreateInfo* pMultisampleState;
+ const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ const PipelineColorBlendStateCreateInfo* pColorBlendState;
+ const PipelineDynamicStateCreateInfo* pDynamicState;
+ PipelineLayout layout;
+ RenderPass renderPass;
+ uint32_t subpass;
+ Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ };
+ static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceLimits
+ {
+ operator const VkPhysicalDeviceLimits&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
+ }
+
+ bool operator==( PhysicalDeviceLimits const& rhs ) const
+ {
+ return ( maxImageDimension1D == rhs.maxImageDimension1D )
+ && ( maxImageDimension2D == rhs.maxImageDimension2D )
+ && ( maxImageDimension3D == rhs.maxImageDimension3D )
+ && ( maxImageDimensionCube == rhs.maxImageDimensionCube )
+ && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+ && ( maxTexelBufferElements == rhs.maxTexelBufferElements )
+ && ( maxUniformBufferRange == rhs.maxUniformBufferRange )
+ && ( maxStorageBufferRange == rhs.maxStorageBufferRange )
+ && ( maxPushConstantsSize == rhs.maxPushConstantsSize )
+ && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount )
+ && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount )
+ && ( bufferImageGranularity == rhs.bufferImageGranularity )
+ && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize )
+ && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets )
+ && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers )
+ && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers )
+ && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers )
+ && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages )
+ && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages )
+ && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments )
+ && ( maxPerStageResources == rhs.maxPerStageResources )
+ && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers )
+ && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers )
+ && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic )
+ && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers )
+ && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic )
+ && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages )
+ && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages )
+ && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments )
+ && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes )
+ && ( maxVertexInputBindings == rhs.maxVertexInputBindings )
+ && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset )
+ && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride )
+ && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents )
+ && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel )
+ && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize )
+ && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents )
+ && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents )
+ && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents )
+ && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents )
+ && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents )
+ && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents )
+ && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations )
+ && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents )
+ && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents )
+ && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices )
+ && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents )
+ && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents )
+ && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments )
+ && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
+ && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
+ && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
+ && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
+ && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
+ && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
+ && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
+ && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue )
+ && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount )
+ && ( maxSamplerLodBias == rhs.maxSamplerLodBias )
+ && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy )
+ && ( maxViewports == rhs.maxViewports )
+ && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
+ && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
+ && ( viewportSubPixelBits == rhs.viewportSubPixelBits )
+ && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
+ && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
+ && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment )
+ && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment )
+ && ( minTexelOffset == rhs.minTexelOffset )
+ && ( maxTexelOffset == rhs.maxTexelOffset )
+ && ( minTexelGatherOffset == rhs.minTexelGatherOffset )
+ && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset )
+ && ( minInterpolationOffset == rhs.minInterpolationOffset )
+ && ( maxInterpolationOffset == rhs.maxInterpolationOffset )
+ && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits )
+ && ( maxFramebufferWidth == rhs.maxFramebufferWidth )
+ && ( maxFramebufferHeight == rhs.maxFramebufferHeight )
+ && ( maxFramebufferLayers == rhs.maxFramebufferLayers )
+ && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts )
+ && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts )
+ && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts )
+ && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts )
+ && ( maxColorAttachments == rhs.maxColorAttachments )
+ && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts )
+ && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts )
+ && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts )
+ && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts )
+ && ( storageImageSampleCounts == rhs.storageImageSampleCounts )
+ && ( maxSampleMaskWords == rhs.maxSampleMaskWords )
+ && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics )
+ && ( timestampPeriod == rhs.timestampPeriod )
+ && ( maxClipDistances == rhs.maxClipDistances )
+ && ( maxCullDistances == rhs.maxCullDistances )
+ && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances )
+ && ( discreteQueuePriorities == rhs.discreteQueuePriorities )
+ && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
+ && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
+ && ( pointSizeGranularity == rhs.pointSizeGranularity )
+ && ( lineWidthGranularity == rhs.lineWidthGranularity )
+ && ( strictLines == rhs.strictLines )
+ && ( standardSampleLocations == rhs.standardSampleLocations )
+ && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment )
+ && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment )
+ && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+ }
+
+ bool operator!=( PhysicalDeviceLimits const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t maxImageDimension1D;
+ uint32_t maxImageDimension2D;
+ uint32_t maxImageDimension3D;
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+ uint32_t maxTexelBufferElements;
+ uint32_t maxUniformBufferRange;
+ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
+ uint32_t maxSamplerAllocationCount;
+ DeviceSize bufferImageGranularity;
+ DeviceSize sparseAddressSpaceSize;
+ uint32_t maxBoundDescriptorSets;
+ uint32_t maxPerStageDescriptorSamplers;
+ uint32_t maxPerStageDescriptorUniformBuffers;
+ uint32_t maxPerStageDescriptorStorageBuffers;
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
+ uint32_t maxPerStageDescriptorInputAttachments;
+ uint32_t maxPerStageResources;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetUniformBuffersDynamic;
+ uint32_t maxDescriptorSetStorageBuffers;
+ uint32_t maxDescriptorSetStorageBuffersDynamic;
+ uint32_t maxDescriptorSetSampledImages;
+ uint32_t maxDescriptorSetStorageImages;
+ uint32_t maxDescriptorSetInputAttachments;
+ uint32_t maxVertexInputAttributes;
+ uint32_t maxVertexInputBindings;
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+ uint32_t maxTessellationGenerationLevel;
+ uint32_t maxTessellationPatchSize;
+ uint32_t maxTessellationControlPerVertexInputComponents;
+ uint32_t maxTessellationControlPerVertexOutputComponents;
+ uint32_t maxTessellationControlPerPatchOutputComponents;
+ uint32_t maxTessellationControlTotalOutputComponents;
+ uint32_t maxTessellationEvaluationInputComponents;
uint32_t maxTessellationEvaluationOutputComponents;
uint32_t maxGeometryShaderInvocations;
uint32_t maxGeometryInputComponents;
DeviceSize optimalBufferCopyRowPitchAlignment;
DeviceSize nonCoherentAtomSize;
};
- static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceProperties
+ {
+ operator const VkPhysicalDeviceProperties&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
+ }
+
+ bool operator==( PhysicalDeviceProperties const& rhs ) const
+ {
+ return ( apiVersion == rhs.apiVersion )
+ && ( driverVersion == rhs.driverVersion )
+ && ( vendorID == rhs.vendorID )
+ && ( deviceID == rhs.deviceID )
+ && ( deviceType == rhs.deviceType )
+ && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
+ && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
+ && ( limits == rhs.limits )
+ && ( sparseProperties == rhs.sparseProperties );
+ }
+
+ bool operator!=( PhysicalDeviceProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t apiVersion;
+ uint32_t driverVersion;
+ uint32_t vendorID;
+ uint32_t deviceID;
+ PhysicalDeviceType deviceType;
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+ uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+ PhysicalDeviceLimits limits;
+ PhysicalDeviceSparseProperties sparseProperties;
+ };
+ static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceProperties2KHR
+ {
+ operator const VkPhysicalDeviceProperties2KHR&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceProperties2KHR*>(this);
+ }
+
+ bool operator==( PhysicalDeviceProperties2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( properties == rhs.properties );
+ }
+
+ bool operator!=( PhysicalDeviceProperties2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ PhysicalDeviceProperties properties;
+ };
+ static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" );
+
+ struct ImageFormatProperties2KHR
+ {
+ operator const VkImageFormatProperties2KHR&() const
+ {
+ return *reinterpret_cast<const VkImageFormatProperties2KHR*>(this);
+ }
+
+ bool operator==( ImageFormatProperties2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( imageFormatProperties == rhs.imageFormatProperties );
+ }
+
+ bool operator!=( ImageFormatProperties2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ 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_ )
+ , type( type_ )
+ , samples( samples_ )
+ , usage( usage_ )
+ , tiling( tiling_ )
+ {
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) );
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) );
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& setType( ImageType type_ )
+ {
+ type = type_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2KHR& setTiling( ImageTiling tiling_ )
+ {
+ tiling = tiling_;
+ return *this;
+ }
+
+ operator const VkPhysicalDeviceSparseImageFormatInfo2KHR&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>(this);
+ }
+
+ bool operator==( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( format == rhs.format )
+ && ( type == rhs.type )
+ && ( samples == rhs.samples )
+ && ( usage == rhs.usage )
+ && ( tiling == rhs.tiling );
+ }
+
+ bool operator!=( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ Format format;
+ ImageType type;
+ SampleCountFlagBits samples;
+ ImageUsageFlags usage;
+ ImageTiling tiling;
+ };
+ static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2KHR ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceProperties2KHX
+ {
+ operator const VkPhysicalDeviceProperties2KHX&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceProperties2KHX*>(this);
+ }
+
+ bool operator==( PhysicalDeviceProperties2KHX const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( properties == rhs.properties );
+ }
+
+ bool operator!=( PhysicalDeviceProperties2KHX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ PhysicalDeviceProperties properties;
+ };
+ static_assert( sizeof( PhysicalDeviceProperties2KHX ) == sizeof( VkPhysicalDeviceProperties2KHX ), "struct and wrapper have different size!" );
+
+ struct ImageFormatProperties2KHX
+ {
+ operator const VkImageFormatProperties2KHX&() const
+ {
+ return *reinterpret_cast<const VkImageFormatProperties2KHX*>(this);
+ }
+
+ bool operator==( ImageFormatProperties2KHX const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( imageFormatProperties == rhs.imageFormatProperties );
+ }
+
+ bool operator!=( ImageFormatProperties2KHX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ ImageFormatProperties imageFormatProperties;
+ };
+ static_assert( sizeof( ImageFormatProperties2KHX ) == sizeof( VkImageFormatProperties2KHX ), "struct and wrapper have different size!" );
+
+ enum class AttachmentDescriptionFlagBits
+ {
+ eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+ };
+
+ using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
+
+ VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
+ {
+ return ~( AttachmentDescriptionFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<AttachmentDescriptionFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
+ };
+ };
+
+ struct AttachmentDescription
+ {
+ AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), Format format_ = Format::eUndefined, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, ImageLayout initialLayout_ = ImageLayout::eUndefined, ImageLayout finalLayout_ = ImageLayout::eUndefined )
+ : flags( flags_ )
+ , format( format_ )
+ , samples( samples_ )
+ , loadOp( loadOp_ )
+ , storeOp( storeOp_ )
+ , stencilLoadOp( stencilLoadOp_ )
+ , stencilStoreOp( stencilStoreOp_ )
+ , initialLayout( initialLayout_ )
+ , finalLayout( finalLayout_ )
+ {
+ }
+
+ AttachmentDescription( VkAttachmentDescription const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(AttachmentDescription) );
+ }
+
+ AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(AttachmentDescription) );
+ return *this;
+ }
+
+ AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ AttachmentDescription& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
+ {
+ loadOp = loadOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
+ {
+ storeOp = storeOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ {
+ stencilLoadOp = stencilLoadOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ {
+ stencilStoreOp = stencilStoreOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
+ {
+ initialLayout = initialLayout_;
+ return *this;
+ }
+
+ AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
+ {
+ finalLayout = finalLayout_;
+ return *this;
+ }
+
+ operator const VkAttachmentDescription&() const
+ {
+ return *reinterpret_cast<const VkAttachmentDescription*>(this);
+ }
+
+ bool operator==( AttachmentDescription const& rhs ) const
+ {
+ return ( flags == rhs.flags )
+ && ( format == rhs.format )
+ && ( samples == rhs.samples )
+ && ( loadOp == rhs.loadOp )
+ && ( storeOp == rhs.storeOp )
+ && ( stencilLoadOp == rhs.stencilLoadOp )
+ && ( stencilStoreOp == rhs.stencilStoreOp )
+ && ( initialLayout == rhs.initialLayout )
+ && ( finalLayout == rhs.finalLayout );
+ }
+
+ bool operator!=( AttachmentDescription const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ AttachmentDescriptionFlags flags;
+ Format format;
+ SampleCountFlagBits samples;
+ AttachmentLoadOp loadOp;
+ AttachmentStoreOp storeOp;
+ AttachmentLoadOp stencilLoadOp;
+ AttachmentStoreOp stencilStoreOp;
+ ImageLayout initialLayout;
+ ImageLayout finalLayout;
+ };
+ static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
+
+ enum class StencilFaceFlagBits
+ {
+ eFront = VK_STENCIL_FACE_FRONT_BIT,
+ eBack = VK_STENCIL_FACE_BACK_BIT,
+ eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
+ };
+
+ using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
+
+ VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
+ {
+ return ~( StencilFaceFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<StencilFaceFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
+ };
+ };
+
+ enum class DescriptorPoolCreateFlagBits
+ {
+ eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
+ };
+
+ using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
+
+ VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
+ {
+ return ~( DescriptorPoolCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet)
+ };
+ };
+
+ 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_ )
+ , maxSets( maxSets_ )
+ , poolSizeCount( poolSizeCount_ )
+ , pPoolSizes( pPoolSizes_ )
+ {
+ }
+
+ DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
+ }
+
+ DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
+ {
+ maxSets = maxSets_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
+ {
+ poolSizeCount = poolSizeCount_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
+ {
+ pPoolSizes = pPoolSizes_;
+ return *this;
+ }
+
+ operator const VkDescriptorPoolCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
+ }
+
+ bool operator==( DescriptorPoolCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( maxSets == rhs.maxSets )
+ && ( poolSizeCount == rhs.poolSizeCount )
+ && ( pPoolSizes == rhs.pPoolSizes );
+ }
+
+ bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+ uint32_t poolSizeCount;
+ const DescriptorPoolSize* pPoolSizes;
+ };
+ static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
+
+ enum class DependencyFlagBits
+ {
+ eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
+ eViewLocalKHX = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX,
+ eDeviceGroupKHX = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX
+ };
+
+ using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
+
+ VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
+ {
+ return ~( DependencyFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<DependencyFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eViewLocalKHX) | VkFlags(DependencyFlagBits::eDeviceGroupKHX)
+ };
+ };
+
+ struct SubpassDependency
+ {
+ SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() )
+ : srcSubpass( srcSubpass_ )
+ , dstSubpass( dstSubpass_ )
+ , srcStageMask( srcStageMask_ )
+ , dstStageMask( dstStageMask_ )
+ , srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , dependencyFlags( dependencyFlags_ )
+ {
+ }
+
+ SubpassDependency( VkSubpassDependency const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SubpassDependency) );
+ }
+
+ SubpassDependency& operator=( VkSubpassDependency const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SubpassDependency) );
+ return *this;
+ }
+
+ SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
+ {
+ srcSubpass = srcSubpass_;
+ return *this;
+ }
+
+ SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
+ {
+ dstSubpass = dstSubpass_;
+ return *this;
+ }
+
+ SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ {
+ srcStageMask = srcStageMask_;
+ return *this;
+ }
+
+ SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
+ {
+ dstStageMask = dstStageMask_;
+ return *this;
+ }
+
+ SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ {
+ srcAccessMask = srcAccessMask_;
+ return *this;
+ }
+
+ SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
+ {
+ dstAccessMask = dstAccessMask_;
+ return *this;
+ }
+
+ SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
+ {
+ dependencyFlags = dependencyFlags_;
+ return *this;
+ }
+
+ operator const VkSubpassDependency&() const
+ {
+ return *reinterpret_cast<const VkSubpassDependency*>(this);
+ }
+
+ bool operator==( SubpassDependency const& rhs ) const
+ {
+ return ( srcSubpass == rhs.srcSubpass )
+ && ( dstSubpass == rhs.dstSubpass )
+ && ( srcStageMask == rhs.srcStageMask )
+ && ( dstStageMask == rhs.dstStageMask )
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( dependencyFlags == rhs.dependencyFlags );
+ }
+
+ bool operator!=( SubpassDependency const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ PipelineStageFlags srcStageMask;
+ PipelineStageFlags dstStageMask;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ DependencyFlags dependencyFlags;
+ };
+ static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
+
+ enum class PresentModeKHR
+ {
+ eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
+ eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
+ eFifo = VK_PRESENT_MODE_FIFO_KHR,
+ eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR
+ };
+
+ enum class ColorSpaceKHR
+ {
+ eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
+ };
+
+ struct SurfaceFormatKHR
+ {
+ operator const VkSurfaceFormatKHR&() const
+ {
+ return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
+ }
+
+ bool operator==( SurfaceFormatKHR const& rhs ) const
+ {
+ return ( format == rhs.format )
+ && ( colorSpace == rhs.colorSpace );
+ }
+
+ bool operator!=( SurfaceFormatKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Format format;
+ ColorSpaceKHR colorSpace;
+ };
+ static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
+
+ enum class DisplayPlaneAlphaFlagBitsKHR
+ {
+ eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
+ eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
+ ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
+ ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
+ };
+
+ using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
+
+ VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
+ {
+ return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
+ };
+ };
+
+ struct DisplayPlaneCapabilitiesKHR
+ {
+ operator const VkDisplayPlaneCapabilitiesKHR&() const
+ {
+ return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
+ }
+
+ bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ {
+ return ( supportedAlpha == rhs.supportedAlpha )
+ && ( minSrcPosition == rhs.minSrcPosition )
+ && ( maxSrcPosition == rhs.maxSrcPosition )
+ && ( minSrcExtent == rhs.minSrcExtent )
+ && ( maxSrcExtent == rhs.maxSrcExtent )
+ && ( minDstPosition == rhs.minDstPosition )
+ && ( maxDstPosition == rhs.maxDstPosition )
+ && ( minDstExtent == rhs.minDstExtent )
+ && ( maxDstExtent == rhs.maxDstExtent );
+ }
+
+ bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DisplayPlaneAlphaFlagsKHR supportedAlpha;
+ Offset2D minSrcPosition;
+ Offset2D maxSrcPosition;
+ Extent2D minSrcExtent;
+ Extent2D maxSrcExtent;
+ Offset2D minDstPosition;
+ Offset2D maxDstPosition;
+ Extent2D minDstExtent;
+ Extent2D maxDstExtent;
+ };
+ static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+ enum class CompositeAlphaFlagBitsKHR
+ {
+ eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+ ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+ ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+ eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
+ };
+
+ using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
+
+ VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
+ {
+ return ~( CompositeAlphaFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
+ };
+ };
+
+ enum class SurfaceTransformFlagBitsKHR
+ {
+ eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
+ eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
+ eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
+ eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
+ eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
+ eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
+ eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
+ eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
+ eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
+ };
+
+ using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
+
+ VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
+ {
+ return ~( SurfaceTransformFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
+ };
+ };
+
+ struct DisplayPropertiesKHR
+ {
+ operator const VkDisplayPropertiesKHR&() const
+ {
+ return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
+ }
+
+ bool operator==( DisplayPropertiesKHR const& rhs ) const
+ {
+ return ( display == rhs.display )
+ && ( displayName == rhs.displayName )
+ && ( physicalDimensions == rhs.physicalDimensions )
+ && ( physicalResolution == rhs.physicalResolution )
+ && ( supportedTransforms == rhs.supportedTransforms )
+ && ( planeReorderPossible == rhs.planeReorderPossible )
+ && ( persistentContent == rhs.persistentContent );
+ }
+
+ bool operator!=( DisplayPropertiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DisplayKHR display;
+ const char* displayName;
+ Extent2D physicalDimensions;
+ Extent2D physicalResolution;
+ SurfaceTransformFlagsKHR supportedTransforms;
+ Bool32 planeReorderPossible;
+ Bool32 persistentContent;
+ };
+ static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "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_ )
+ , displayMode( displayMode_ )
+ , planeIndex( planeIndex_ )
+ , planeStackIndex( planeStackIndex_ )
+ , transform( transform_ )
+ , globalAlpha( globalAlpha_ )
+ , alphaMode( alphaMode_ )
+ , imageExtent( imageExtent_ )
+ {
+ }
+
+ DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
+ }
+
+ DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
+ {
+ displayMode = displayMode_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
+ {
+ planeIndex = planeIndex_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
+ {
+ planeStackIndex = planeStackIndex_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
+ {
+ transform = transform_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
+ {
+ globalAlpha = globalAlpha_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
+ {
+ alphaMode = alphaMode_;
+ return *this;
+ }
+
+ DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ {
+ imageExtent = imageExtent_;
+ return *this;
+ }
+
+ operator const VkDisplaySurfaceCreateInfoKHR&() const
+ {
+ return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
+ }
+
+ bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( displayMode == rhs.displayMode )
+ && ( planeIndex == rhs.planeIndex )
+ && ( planeStackIndex == rhs.planeStackIndex )
+ && ( transform == rhs.transform )
+ && ( globalAlpha == rhs.globalAlpha )
+ && ( alphaMode == rhs.alphaMode )
+ && ( imageExtent == rhs.imageExtent );
+ }
+
+ bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DisplaySurfaceCreateFlagsKHR flags;
+ DisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+ SurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+ DisplayPlaneAlphaFlagBitsKHR alphaMode;
+ Extent2D imageExtent;
+ };
+ static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+
+ struct SurfaceCapabilitiesKHR
+ {
+ operator const VkSurfaceCapabilitiesKHR&() const
+ {
+ return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
+ }
+
+ bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
+ {
+ return ( minImageCount == rhs.minImageCount )
+ && ( maxImageCount == rhs.maxImageCount )
+ && ( currentExtent == rhs.currentExtent )
+ && ( minImageExtent == rhs.minImageExtent )
+ && ( maxImageExtent == rhs.maxImageExtent )
+ && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+ && ( supportedTransforms == rhs.supportedTransforms )
+ && ( currentTransform == rhs.currentTransform )
+ && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
+ && ( supportedUsageFlags == rhs.supportedUsageFlags );
+ }
+
+ bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ Extent2D currentExtent;
+ Extent2D minImageExtent;
+ Extent2D maxImageExtent;
+ uint32_t maxImageArrayLayers;
+ SurfaceTransformFlagsKHR supportedTransforms;
+ SurfaceTransformFlagBitsKHR currentTransform;
+ CompositeAlphaFlagsKHR supportedCompositeAlpha;
+ ImageUsageFlags supportedUsageFlags;
+ };
+ static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+ enum class DebugReportFlagBitsEXT
+ {
+ eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
+ eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
+ ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
+ eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
+ eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
+ };
+
+ using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
+
+ VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+ {
+ return DebugReportFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
+ {
+ return ~( DebugReportFlagsEXT( bits ) );
+ }
+
+ template <> struct FlagTraits<DebugReportFlagBitsEXT>
+ {
+ enum
+ {
+ allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
+ };
+ };
+
+ struct DebugReportCallbackCreateInfoEXT
+ {
+ DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr )
+ : sType( StructureType::eDebugReportCallbackCreateInfoEXT )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , pfnCallback( pfnCallback_ )
+ , pUserData( pUserData_ )
+ {
+ }
+
+ DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
+ }
+
+ DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
+ return *this;
+ }
+
+ DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
+ {
+ pfnCallback = pfnCallback_;
+ return *this;
+ }
+
+ DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
+ {
+ pUserData = pUserData_;
+ return *this;
+ }
+
+ operator const VkDebugReportCallbackCreateInfoEXT&() const
+ {
+ return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
+ }
+
+ bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( pfnCallback == rhs.pfnCallback )
+ && ( pUserData == rhs.pUserData );
+ }
+
+ bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DebugReportFlagsEXT flags;
+ PFN_vkDebugReportCallbackEXT pfnCallback;
+ void* pUserData;
+ };
+ static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
+
+ enum class DebugReportObjectTypeEXT
+ {
+ eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+ eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
+ ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+ eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+ eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
+ eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+ eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+ eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
+ eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
+ eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+ eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+ eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
+ eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
+ eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
+ eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+ eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
+ ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
+ ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
+ eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+ ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+ eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
+ eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
+ eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
+ eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+ eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
+ eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
+ eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
+ eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+ eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
+ eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
+ eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
+ eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
+ eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT
+ };
+
+ struct DebugMarkerObjectNameInfoEXT
+ {
+ DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr )
+ : sType( StructureType::eDebugMarkerObjectNameInfoEXT )
+ , pNext( nullptr )
+ , objectType( objectType_ )
+ , object( object_ )
+ , pObjectName( pObjectName_ )
+ {
+ }
+
+ DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
+ }
+
+ DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
+ return *this;
+ }
+
+ DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
+ {
+ objectType = objectType_;
+ return *this;
+ }
+
+ DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
+ {
+ object = object_;
+ return *this;
+ }
+
+ DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
+ {
+ pObjectName = pObjectName_;
+ return *this;
+ }
+
+ operator const VkDebugMarkerObjectNameInfoEXT&() const
+ {
+ return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
+ }
+
+ bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( objectType == rhs.objectType )
+ && ( object == rhs.object )
+ && ( pObjectName == rhs.pObjectName );
+ }
+
+ bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ const char* pObjectName;
+ };
+ static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
+
+ 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_ )
+ , object( object_ )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
+ {
+ }
+
+ DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
+ }
+
+ DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
+ return *this;
+ }
+
+ DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
+ {
+ objectType = objectType_;
+ return *this;
+ }
+
+ DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
+ {
+ object = object_;
+ return *this;
+ }
+
+ DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
+ {
+ tagName = tagName_;
+ return *this;
+ }
+
+ DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
+ {
+ tagSize = tagSize_;
+ return *this;
+ }
+
+ DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
+ {
+ pTag = pTag_;
+ return *this;
+ }
+
+ operator const VkDebugMarkerObjectTagInfoEXT&() const
+ {
+ return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
+ }
+
+ bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( objectType == rhs.objectType )
+ && ( object == rhs.object )
+ && ( tagName == rhs.tagName )
+ && ( tagSize == rhs.tagSize )
+ && ( pTag == rhs.pTag );
+ }
+
+ bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
+ };
+ static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
+
+ enum class DebugReportErrorEXT
+ {
+ eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT,
+ eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT
+ };
+
+ enum class RasterizationOrderAMD
+ {
+ eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
+ eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
+ };
+
+ struct PipelineRasterizationStateRasterizationOrderAMD
+ {
+ PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
+ : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD )
+ , pNext( nullptr )
+ , rasterizationOrder( rasterizationOrder_ )
+ {
+ }
+
+ PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
+ }
+
+ PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
+ return *this;
+ }
+
+ PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
+ {
+ rasterizationOrder = rasterizationOrder_;
+ return *this;
+ }
+
+ operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
+ {
+ return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
+ }
+
+ bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( rasterizationOrder == rhs.rasterizationOrder );
+ }
+
+ bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ RasterizationOrderAMD rasterizationOrder;
+ };
+ static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
+
+ enum class ExternalMemoryHandleTypeFlagBitsNV
+ {
+ eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
+ eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
+ eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
+ eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
+ };
+
+ using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
+
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
+ {
+ return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
+ {
+ enum
+ {
+ allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
+ };
+ };
+
+ struct ExternalMemoryImageCreateInfoNV
+ {
+ ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
+ : sType( StructureType::eExternalMemoryImageCreateInfoNV )
+ , pNext( nullptr )
+ , handleTypes( handleTypes_ )
+ {
+ }
+
+ ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
+ }
+
+ ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
+ return *this;
+ }
+
+ ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ {
+ handleTypes = handleTypes_;
+ return *this;
+ }
+
+ operator const VkExternalMemoryImageCreateInfoNV&() const
+ {
+ return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
+ }
+
+ bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleTypes == rhs.handleTypes );
+ }
+
+ bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ 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_ )
+ {
+ }
+
+ ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
+ }
+
+ ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
+ return *this;
+ }
+
+ ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ {
+ handleTypes = handleTypes_;
+ return *this;
+ }
+
+ operator const VkExportMemoryAllocateInfoNV&() const
+ {
+ return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
+ }
+
+ bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleTypes == rhs.handleTypes );
+ }
+
+ bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ ExternalMemoryHandleTypeFlagsNV handleTypes;
+ };
+ static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct ImportMemoryWin32HandleInfoNV
+ {
+ ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
+ : sType( StructureType::eImportMemoryWin32HandleInfoNV )
+ , pNext( nullptr )
+ , handleType( handleType_ )
+ , handle( handle_ )
+ {
+ }
+
+ ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
+ }
+
+ ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
+ return *this;
+ }
+
+ ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
+ {
+ handleType = handleType_;
+ return *this;
+ }
+
+ ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
+ {
+ handle = handle_;
+ return *this;
+ }
+
+ operator const VkImportMemoryWin32HandleInfoNV&() const
+ {
+ return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
+ }
+
+ bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleType == rhs.handleType )
+ && ( handle == rhs.handle );
+ }
+
+ bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ ExternalMemoryHandleTypeFlagsNV handleType;
+ HANDLE handle;
+ };
+ static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ enum class ExternalMemoryFeatureFlagBitsNV
+ {
+ eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
+ eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
+ eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
+ };
+
+ using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
+
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+ {
+ return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
+ {
+ return ~( ExternalMemoryFeatureFlagsNV( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
+ {
+ enum
+ {
+ allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
+ };
+ };
+
+ struct ExternalImageFormatPropertiesNV
+ {
+ operator const VkExternalImageFormatPropertiesNV&() const
+ {
+ return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
+ }
+
+ bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
+ {
+ return ( imageFormatProperties == rhs.imageFormatProperties )
+ && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+ }
+
+ bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageFormatProperties imageFormatProperties;
+ ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
+ ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
+ ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
+ };
+ static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
+
+ enum class ValidationCheckEXT
+ {
+ eAll = VK_VALIDATION_CHECK_ALL_EXT
+ };
+
+ struct ValidationFlagsEXT
+ {
+ ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+ : sType( StructureType::eValidationFlagsEXT )
+ , pNext( nullptr )
+ , disabledValidationCheckCount( disabledValidationCheckCount_ )
+ , pDisabledValidationChecks( pDisabledValidationChecks_ )
+ {
+ }
+
+ ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
+ }
+
+ ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
+ return *this;
+ }
+
+ ValidationFlagsEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
+ {
+ disabledValidationCheckCount = disabledValidationCheckCount_;
+ return *this;
+ }
+
+ ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ )
+ {
+ pDisabledValidationChecks = pDisabledValidationChecks_;
+ return *this;
+ }
+
+ operator const VkValidationFlagsEXT&() const
+ {
+ return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
+ }
+
+ bool operator==( ValidationFlagsEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
+ && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+ }
+
+ bool operator!=( ValidationFlagsEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t disabledValidationCheckCount;
+ ValidationCheckEXT* pDisabledValidationChecks;
+ };
+ static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
+
+ enum class IndirectCommandsLayoutUsageFlagBitsNVX
+ {
+ eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
+ eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
+ eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
+ eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
+ };
+
+ using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
+
+ VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
+ {
+ return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
+ }
+
+ template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
+ {
+ enum
+ {
+ allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
+ };
+ };
+
+ enum class ObjectEntryUsageFlagBitsNVX
+ {
+ eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
+ eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
+ };
+
+ using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
+
+ VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
+ {
+ return ~( ObjectEntryUsageFlagsNVX( bits ) );
+ }
+
+ template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
+ {
+ enum
+ {
+ allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
+ };
+ };
+
+ enum class IndirectCommandsTokenTypeNVX
+ {
+ eVkIndirectCommandsTokenPipeline = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX,
+ eVkIndirectCommandsTokenDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX,
+ eVkIndirectCommandsTokenIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX,
+ eVkIndirectCommandsTokenVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX,
+ eVkIndirectCommandsTokenPushConstant = VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX,
+ eVkIndirectCommandsTokenDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX,
+ eVkIndirectCommandsTokenDraw = VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX,
+ eVkIndirectCommandsTokenDispatch = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX
+ };
+
+ struct IndirectCommandsTokenNVX
+ {
+ IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 )
+ : tokenType( tokenType_ )
+ , buffer( buffer_ )
+ , offset( offset_ )
+ {
+ }
+
+ IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) );
+ }
+
+ IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) );
+ return *this;
+ }
+
+ IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ {
+ tokenType = tokenType_;
+ return *this;
+ }
+
+ IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ )
+ {
+ buffer = buffer_;
+ return *this;
+ }
- struct PhysicalDeviceProperties
- {
- operator const VkPhysicalDeviceProperties&() const
+ IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
+ offset = offset_;
+ return *this;
}
- bool operator==( PhysicalDeviceProperties const& rhs ) const
+ operator const VkIndirectCommandsTokenNVX&() const
{
- return ( apiVersion == rhs.apiVersion )
- && ( driverVersion == rhs.driverVersion )
- && ( vendorID == rhs.vendorID )
- && ( deviceID == rhs.deviceID )
- && ( deviceType == rhs.deviceType )
- && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
- && ( limits == rhs.limits )
- && ( sparseProperties == rhs.sparseProperties );
+ return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
}
- bool operator!=( PhysicalDeviceProperties const& rhs ) const
+ bool operator==( IndirectCommandsTokenNVX const& rhs ) const
+ {
+ return ( tokenType == rhs.tokenType )
+ && ( buffer == rhs.buffer )
+ && ( offset == rhs.offset );
+ }
+
+ bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t apiVersion;
- uint32_t driverVersion;
- uint32_t vendorID;
- uint32_t deviceID;
- PhysicalDeviceType deviceType;
- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
- uint8_t pipelineCacheUUID[VK_UUID_SIZE];
- PhysicalDeviceLimits limits;
- PhysicalDeviceSparseProperties sparseProperties;
+ IndirectCommandsTokenTypeNVX tokenType;
+ Buffer buffer;
+ DeviceSize offset;
};
- static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
+ static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
- struct PhysicalDeviceProperties2KHR
+ struct IndirectCommandsLayoutTokenNVX
{
- operator const VkPhysicalDeviceProperties2KHR&() const
+ IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 )
+ : tokenType( tokenType_ )
+ , bindingUnit( bindingUnit_ )
+ , dynamicCount( dynamicCount_ )
+ , divisor( divisor_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceProperties2KHR*>(this);
}
- bool operator==( PhysicalDeviceProperties2KHR const& rhs ) const
+ IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( properties == rhs.properties );
+ memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) );
}
- bool operator!=( PhysicalDeviceProperties2KHR const& rhs ) const
+ IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) );
+ return *this;
}
- private:
- StructureType sType;
+ IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ {
+ tokenType = tokenType_;
+ return *this;
+ }
- public:
- void* pNext;
- PhysicalDeviceProperties properties;
- };
- static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" );
+ IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ )
+ {
+ bindingUnit = bindingUnit_;
+ return *this;
+ }
- struct ImageFormatProperties2KHR
- {
- operator const VkImageFormatProperties2KHR&() const
+ IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ )
{
- return *reinterpret_cast<const VkImageFormatProperties2KHR*>(this);
+ dynamicCount = dynamicCount_;
+ return *this;
}
- bool operator==( ImageFormatProperties2KHR const& rhs ) const
+ IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( imageFormatProperties == rhs.imageFormatProperties );
+ divisor = divisor_;
+ return *this;
}
- bool operator!=( ImageFormatProperties2KHR const& rhs ) const
+ operator const VkIndirectCommandsLayoutTokenNVX&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
}
- private:
- StructureType sType;
+ bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
+ {
+ return ( tokenType == rhs.tokenType )
+ && ( bindingUnit == rhs.bindingUnit )
+ && ( dynamicCount == rhs.dynamicCount )
+ && ( divisor == rhs.divisor );
+ }
- public:
- void* pNext;
- ImageFormatProperties imageFormatProperties;
+ bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ IndirectCommandsTokenTypeNVX tokenType;
+ uint32_t bindingUnit;
+ uint32_t dynamicCount;
+ uint32_t divisor;
};
- static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
- struct PhysicalDeviceSparseImageFormatInfo2KHR
+ struct IndirectCommandsLayoutCreateInfoNVX
{
- PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal )
- : sType( StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR )
+ IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+ : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX )
, pNext( nullptr )
- , format( format_ )
- , type( type_ )
- , samples( samples_ )
- , usage( usage_ )
- , tiling( tiling_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , flags( flags_ )
+ , tokenCount( tokenCount_ )
+ , pTokens( pTokens_ )
{
}
- PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
+ IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) );
}
- PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
+ IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) );
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ )
+ IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2KHR& setFormat( Format format_ )
- {
- format = format_;
- return *this;
- }
-
- PhysicalDeviceSparseImageFormatInfo2KHR& setType( ImageType type_ )
+ IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- type = type_;
+ pipelineBindPoint = pipelineBindPoint_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2KHR& setSamples( SampleCountFlagBits samples_ )
+ IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
{
- samples = samples_;
+ flags = flags_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ )
+ IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ )
{
- usage = usage_;
+ tokenCount = tokenCount_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2KHR& setTiling( ImageTiling tiling_ )
+ IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
{
- tiling = tiling_;
+ pTokens = pTokens_;
return *this;
}
- operator const VkPhysicalDeviceSparseImageFormatInfo2KHR&() const
+ operator const VkIndirectCommandsLayoutCreateInfoNVX&() const
{
- return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>(this);
+ return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
}
- bool operator==( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const
+ bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( format == rhs.format )
- && ( type == rhs.type )
- && ( samples == rhs.samples )
- && ( usage == rhs.usage )
- && ( tiling == rhs.tiling );
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( flags == rhs.flags )
+ && ( tokenCount == rhs.tokenCount )
+ && ( pTokens == rhs.pTokens );
}
- bool operator!=( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const
+ bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- Format format;
- ImageType type;
- SampleCountFlagBits samples;
- ImageUsageFlags usage;
- ImageTiling tiling;
+ PipelineBindPoint pipelineBindPoint;
+ IndirectCommandsLayoutUsageFlagsNVX flags;
+ uint32_t tokenCount;
+ const IndirectCommandsLayoutTokenNVX* pTokens;
};
- static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
- enum class AttachmentDescriptionFlagBits
+ enum class ObjectEntryTypeNVX
{
- eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+ eVkObjectEntryDescriptorSet = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX,
+ eVkObjectEntryPipeline = VK_OBJECT_ENTRY_PIPELINE_NVX,
+ eVkObjectEntryIndexBuffer = VK_OBJECT_ENTRY_INDEX_BUFFER_NVX,
+ eVkObjectEntryVertexBuffer = VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX,
+ eVkObjectEntryPushConstant = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX
};
- using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
-
- VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
- {
- return AttachmentDescriptionFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
- {
- return ~( AttachmentDescriptionFlags( bits ) );
- }
-
- template <> struct FlagTraits<AttachmentDescriptionFlagBits>
+ struct ObjectTableCreateInfoNVX
{
- enum
+ 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_ )
+ , pObjectEntryTypes( pObjectEntryTypes_ )
+ , pObjectEntryCounts( pObjectEntryCounts_ )
+ , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
+ , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
+ , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
+ , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
+ , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
+ , maxPipelineLayouts( maxPipelineLayouts_ )
{
- allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
- };
- };
+ }
- struct AttachmentDescription
- {
- AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), Format format_ = Format::eUndefined, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, ImageLayout initialLayout_ = ImageLayout::eUndefined, ImageLayout finalLayout_ = ImageLayout::eUndefined )
- : flags( flags_ )
- , format( format_ )
- , samples( samples_ )
- , loadOp( loadOp_ )
- , storeOp( storeOp_ )
- , stencilLoadOp( stencilLoadOp_ )
- , stencilStoreOp( stencilStoreOp_ )
- , initialLayout( initialLayout_ )
- , finalLayout( finalLayout_ )
+ ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
{
+ memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) );
}
- AttachmentDescription( VkAttachmentDescription const & rhs )
+ ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(AttachmentDescription) );
+ memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) );
+ return *this;
}
- AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
+ ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
{
- memcpy( this, &rhs, sizeof(AttachmentDescription) );
+ pNext = pNext_;
return *this;
}
- AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
+ ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ )
{
- flags = flags_;
+ objectCount = objectCount_;
return *this;
}
- AttachmentDescription& setFormat( Format format_ )
+ ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
{
- format = format_;
+ pObjectEntryTypes = pObjectEntryTypes_;
return *this;
}
- AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
+ ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
{
- samples = samples_;
+ pObjectEntryCounts = pObjectEntryCounts_;
return *this;
}
- AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
+ ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
{
- loadOp = loadOp_;
+ pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
return *this;
}
- AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
+ ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
{
- storeOp = storeOp_;
+ maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
return *this;
}
- AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
{
- stencilLoadOp = stencilLoadOp_;
+ maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
return *this;
}
- AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
{
- stencilStoreOp = stencilStoreOp_;
+ maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
return *this;
}
- AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
+ ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
{
- initialLayout = initialLayout_;
+ maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
return *this;
}
- AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
+ ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
{
- finalLayout = finalLayout_;
+ maxPipelineLayouts = maxPipelineLayouts_;
return *this;
}
- operator const VkAttachmentDescription&() const
+ operator const VkObjectTableCreateInfoNVX&() const
{
- return *reinterpret_cast<const VkAttachmentDescription*>(this);
+ return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
}
- bool operator==( AttachmentDescription const& rhs ) const
+ bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
{
- return ( flags == rhs.flags )
- && ( format == rhs.format )
- && ( samples == rhs.samples )
- && ( loadOp == rhs.loadOp )
- && ( storeOp == rhs.storeOp )
- && ( stencilLoadOp == rhs.stencilLoadOp )
- && ( stencilStoreOp == rhs.stencilStoreOp )
- && ( initialLayout == rhs.initialLayout )
- && ( finalLayout == rhs.finalLayout );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( objectCount == rhs.objectCount )
+ && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
+ && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
+ && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
+ && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
+ && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
+ && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
+ && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
+ && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
}
- bool operator!=( AttachmentDescription const& rhs ) const
+ bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
{
return !operator==( rhs );
}
- AttachmentDescriptionFlags flags;
- Format format;
- SampleCountFlagBits samples;
- AttachmentLoadOp loadOp;
- AttachmentStoreOp storeOp;
- AttachmentLoadOp stencilLoadOp;
- AttachmentStoreOp stencilStoreOp;
- ImageLayout initialLayout;
- ImageLayout finalLayout;
- };
- static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
-
- enum class StencilFaceFlagBits
- {
- eFront = VK_STENCIL_FACE_FRONT_BIT,
- eBack = VK_STENCIL_FACE_BACK_BIT,
- eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
- };
-
- using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
-
- VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
- {
- return StencilFaceFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
- {
- return ~( StencilFaceFlags( bits ) );
- }
-
- template <> struct FlagTraits<StencilFaceFlagBits>
- {
- enum
- {
- allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
- };
- };
-
- enum class DescriptorPoolCreateFlagBits
- {
- eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
- };
-
- using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
-
- VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
- {
- return DescriptorPoolCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
- {
- return ~( DescriptorPoolCreateFlags( bits ) );
- }
+ private:
+ StructureType sType;
- template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
- {
- enum
- {
- allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet)
- };
+ public:
+ const void* pNext;
+ uint32_t objectCount;
+ const ObjectEntryTypeNVX* pObjectEntryTypes;
+ const uint32_t* pObjectEntryCounts;
+ const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
+ uint32_t maxUniformBuffersPerDescriptor;
+ uint32_t maxStorageBuffersPerDescriptor;
+ uint32_t maxStorageImagesPerDescriptor;
+ uint32_t maxSampledImagesPerDescriptor;
+ uint32_t maxPipelineLayouts;
};
+ static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
- struct DescriptorPoolCreateInfo
+ struct ObjectTableEntryNVX
{
- DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr )
- : sType( StructureType::eDescriptorPoolCreateInfo )
- , pNext( nullptr )
+ ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
+ : type( type_ )
, flags( flags_ )
- , maxSets( maxSets_ )
- , poolSizeCount( poolSizeCount_ )
- , pPoolSizes( pPoolSizes_ )
{
}
- DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+ ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) );
}
- DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+ ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) );
return *this;
}
- DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
+ ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- pNext = pNext_;
+ type = type_;
return *this;
}
- DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
+ ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
+ operator const VkObjectTableEntryNVX&() const
{
- maxSets = maxSets_;
- return *this;
+ return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
}
- DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
+ bool operator==( ObjectTableEntryNVX const& rhs ) const
{
- poolSizeCount = poolSizeCount_;
- return *this;
+ return ( type == rhs.type )
+ && ( flags == rhs.flags );
}
- DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
+ bool operator!=( ObjectTableEntryNVX const& rhs ) const
{
- pPoolSizes = pPoolSizes_;
- return *this;
+ return !operator==( rhs );
}
- operator const VkDescriptorPoolCreateInfo&() const
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ };
+ static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
+
+ struct ObjectTablePipelineEntryNVX
+ {
+ ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() )
+ : type( type_ )
+ , flags( flags_ )
+ , pipeline( pipeline_ )
{
- return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
}
- bool operator==( DescriptorPoolCreateInfo const& rhs ) const
+ ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( maxSets == rhs.maxSets )
- && ( poolSizeCount == rhs.poolSizeCount )
- && ( pPoolSizes == rhs.pPoolSizes );
+ memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) );
}
- bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
+ ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) );
+ return *this;
}
- private:
- StructureType sType;
-
- public:
- const void* pNext;
- DescriptorPoolCreateFlags flags;
- uint32_t maxSets;
- uint32_t poolSizeCount;
- const DescriptorPoolSize* pPoolSizes;
- };
- static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
-
- enum class DependencyFlagBits
- {
- eByRegion = VK_DEPENDENCY_BY_REGION_BIT
- };
-
- using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
-
- VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
- {
- return DependencyFlags( bit0 ) | bit1;
- }
+ ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ {
+ type = type_;
+ return *this;
+ }
- VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
- {
- return ~( DependencyFlags( bits ) );
- }
+ ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
- template <> struct FlagTraits<DependencyFlagBits>
- {
- enum
+ ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ )
{
- allFlags = VkFlags(DependencyFlagBits::eByRegion)
- };
- };
+ pipeline = pipeline_;
+ return *this;
+ }
- struct SubpassDependency
- {
- SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() )
- : srcSubpass( srcSubpass_ )
- , dstSubpass( dstSubpass_ )
- , srcStageMask( srcStageMask_ )
- , dstStageMask( dstStageMask_ )
- , srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , dependencyFlags( dependencyFlags_ )
+ operator const VkObjectTablePipelineEntryNVX&() const
{
+ return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
}
- SubpassDependency( VkSubpassDependency const & rhs )
+ bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
{
- memcpy( this, &rhs, sizeof(SubpassDependency) );
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( pipeline == rhs.pipeline );
}
- SubpassDependency& operator=( VkSubpassDependency const & rhs )
+ bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
{
- memcpy( this, &rhs, sizeof(SubpassDependency) );
- return *this;
+ return !operator==( rhs );
}
- SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ Pipeline pipeline;
+ };
+ static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
+
+ struct ObjectTableDescriptorSetEntryNVX
+ {
+ ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() )
+ : type( type_ )
+ , flags( flags_ )
+ , pipelineLayout( pipelineLayout_ )
+ , descriptorSet( descriptorSet_ )
{
- srcSubpass = srcSubpass_;
- return *this;
}
- SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
+ ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- dstSubpass = dstSubpass_;
- return *this;
+ memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) );
}
- SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- srcStageMask = srcStageMask_;
+ memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) );
return *this;
}
- SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
+ ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- dstStageMask = dstStageMask_;
+ type = type_;
return *this;
}
- SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
- srcAccessMask = srcAccessMask_;
+ flags = flags_;
return *this;
}
- SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
+ ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
{
- dstAccessMask = dstAccessMask_;
+ pipelineLayout = pipelineLayout_;
return *this;
}
- SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
+ ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ )
{
- dependencyFlags = dependencyFlags_;
+ descriptorSet = descriptorSet_;
return *this;
}
- operator const VkSubpassDependency&() const
+ operator const VkObjectTableDescriptorSetEntryNVX&() const
{
- return *reinterpret_cast<const VkSubpassDependency*>(this);
+ return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
}
- bool operator==( SubpassDependency const& rhs ) const
+ bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
{
- return ( srcSubpass == rhs.srcSubpass )
- && ( dstSubpass == rhs.dstSubpass )
- && ( srcStageMask == rhs.srcStageMask )
- && ( dstStageMask == rhs.dstStageMask )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( dependencyFlags == rhs.dependencyFlags );
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( pipelineLayout == rhs.pipelineLayout )
+ && ( descriptorSet == rhs.descriptorSet );
}
- bool operator!=( SubpassDependency const& rhs ) const
+ bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t srcSubpass;
- uint32_t dstSubpass;
- PipelineStageFlags srcStageMask;
- PipelineStageFlags dstStageMask;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- DependencyFlags dependencyFlags;
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ PipelineLayout pipelineLayout;
+ DescriptorSet descriptorSet;
};
- static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
- struct RenderPassCreateInfo
+ struct ObjectTableVertexBufferEntryNVX
{
- 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 )
+ ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() )
+ : type( type_ )
, flags( flags_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , subpassCount( subpassCount_ )
- , pSubpasses( pSubpasses_ )
- , dependencyCount( dependencyCount_ )
- , pDependencies( pDependencies_ )
+ , buffer( buffer_ )
{
}
- RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
+ ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
+ memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) );
}
- RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
+ ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
+ memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) );
return *this;
}
- RenderPassCreateInfo& setPNext( const void* pNext_ )
+ ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- pNext = pNext_;
+ type = type_;
return *this;
}
- RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
+ ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
+ ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ )
{
- attachmentCount = attachmentCount_;
+ buffer = buffer_;
return *this;
}
- RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
+ operator const VkObjectTableVertexBufferEntryNVX&() const
{
- pAttachments = pAttachments_;
+ return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
+ }
+
+ bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ {
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( buffer == rhs.buffer );
+ }
+
+ bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ Buffer buffer;
+ };
+ static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
+
+ struct ObjectTableIndexBufferEntryNVX
+ {
+ ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 )
+ : type( type_ )
+ , flags( flags_ )
+ , buffer( buffer_ )
+ , indexType( indexType_ )
+ {
+ }
+
+ ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) );
+ }
+
+ ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) );
return *this;
}
- RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
+ ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- subpassCount = subpassCount_;
+ type = type_;
return *this;
}
- RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
+ ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
- pSubpasses = pSubpasses_;
+ flags = flags_;
return *this;
}
- RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
+ ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ )
{
- dependencyCount = dependencyCount_;
+ buffer = buffer_;
return *this;
}
- RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
+ ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ )
{
- pDependencies = pDependencies_;
+ indexType = indexType_;
return *this;
}
- operator const VkRenderPassCreateInfo&() const
+ operator const VkObjectTableIndexBufferEntryNVX&() const
{
- return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
+ return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
}
- bool operator==( RenderPassCreateInfo const& rhs ) const
+ bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
+ return ( type == rhs.type )
&& ( flags == rhs.flags )
- && ( attachmentCount == rhs.attachmentCount )
- && ( pAttachments == rhs.pAttachments )
- && ( subpassCount == rhs.subpassCount )
- && ( pSubpasses == rhs.pSubpasses )
- && ( dependencyCount == rhs.dependencyCount )
- && ( pDependencies == rhs.pDependencies );
+ && ( buffer == rhs.buffer )
+ && ( indexType == rhs.indexType );
}
- bool operator!=( RenderPassCreateInfo const& rhs ) const
+ bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType;
-
- public:
- const void* pNext;
- RenderPassCreateFlags flags;
- uint32_t attachmentCount;
- const AttachmentDescription* pAttachments;
- uint32_t subpassCount;
- const SubpassDescription* pSubpasses;
- uint32_t dependencyCount;
- const SubpassDependency* pDependencies;
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ Buffer buffer;
+ IndexType indexType;
};
- static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
- enum class PresentModeKHR
+ struct ObjectTablePushConstantEntryNVX
{
- eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
- eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
- eFifo = VK_PRESENT_MODE_FIFO_KHR,
- eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR
- };
+ ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+ : type( type_ )
+ , flags( flags_ )
+ , pipelineLayout( pipelineLayout_ )
+ , stageFlags( stageFlags_ )
+ {
+ }
- enum class ColorSpaceKHR
- {
- eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
- };
+ ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) );
+ }
- struct SurfaceFormatKHR
- {
- operator const VkSurfaceFormatKHR&() const
+ ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) );
+ return *this;
+ }
+
+ ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
+ type = type_;
+ return *this;
}
- bool operator==( SurfaceFormatKHR const& rhs ) const
+ ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
- return ( format == rhs.format )
- && ( colorSpace == rhs.colorSpace );
+ flags = flags_;
+ return *this;
}
- bool operator!=( SurfaceFormatKHR const& rhs ) const
+ ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
{
- return !operator==( rhs );
+ pipelineLayout = pipelineLayout_;
+ return *this;
}
- Format format;
- ColorSpaceKHR colorSpace;
- };
- static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
-
- enum class DisplayPlaneAlphaFlagBitsKHR
- {
- eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
- eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
- ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
- ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
- };
-
- using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
-
- VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
- {
- return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
- {
- return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
- }
-
- template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
- {
- enum
+ ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ )
{
- allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
- };
- };
+ stageFlags = stageFlags_;
+ return *this;
+ }
- struct DisplayPlaneCapabilitiesKHR
- {
- operator const VkDisplayPlaneCapabilitiesKHR&() const
+ operator const VkObjectTablePushConstantEntryNVX&() const
{
- return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
+ return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
}
- bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
{
- return ( supportedAlpha == rhs.supportedAlpha )
- && ( minSrcPosition == rhs.minSrcPosition )
- && ( maxSrcPosition == rhs.maxSrcPosition )
- && ( minSrcExtent == rhs.minSrcExtent )
- && ( maxSrcExtent == rhs.maxSrcExtent )
- && ( minDstPosition == rhs.minDstPosition )
- && ( maxDstPosition == rhs.maxDstPosition )
- && ( minDstExtent == rhs.minDstExtent )
- && ( maxDstExtent == rhs.maxDstExtent );
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( pipelineLayout == rhs.pipelineLayout )
+ && ( stageFlags == rhs.stageFlags );
}
- bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
{
return !operator==( rhs );
}
- DisplayPlaneAlphaFlagsKHR supportedAlpha;
- Offset2D minSrcPosition;
- Offset2D maxSrcPosition;
- Extent2D minSrcExtent;
- Extent2D maxSrcExtent;
- Offset2D minDstPosition;
- Offset2D maxDstPosition;
- Extent2D minDstExtent;
- Extent2D maxDstExtent;
- };
- static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
-
- enum class CompositeAlphaFlagBitsKHR
- {
- eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
- ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
- ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
- eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
- };
-
- using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
-
- VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
- {
- return CompositeAlphaFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
- {
- return ~( CompositeAlphaFlagsKHR( bits ) );
- }
-
- template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
- {
- enum
- {
- allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
- };
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ PipelineLayout pipelineLayout;
+ ShaderStageFlags stageFlags;
};
+ static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
- enum class SurfaceTransformFlagBitsKHR
+ enum class DescriptorSetLayoutCreateFlagBits
{
- eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
- eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
- eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
- eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
- eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
- eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
- eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
- eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
- eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
+ ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR
};
- using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
+ using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
- VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
{
- return SurfaceTransformFlagsKHR( bit0 ) | bit1;
+ return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
+ VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
{
- return ~( SurfaceTransformFlagsKHR( bits ) );
+ return ~( DescriptorSetLayoutCreateFlags( bits ) );
}
- template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
+ template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
{
enum
{
- allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
+ allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR)
};
};
- struct DisplayPropertiesKHR
+ struct DescriptorSetLayoutCreateInfo
{
- operator const VkDisplayPropertiesKHR&() const
+ DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr )
+ : sType( StructureType::eDescriptorSetLayoutCreateInfo )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , bindingCount( bindingCount_ )
+ , pBindings( pBindings_ )
{
- return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
}
- bool operator==( DisplayPropertiesKHR const& rhs ) const
+ DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- return ( display == rhs.display )
- && ( displayName == rhs.displayName )
- && ( physicalDimensions == rhs.physicalDimensions )
- && ( physicalResolution == rhs.physicalResolution )
- && ( supportedTransforms == rhs.supportedTransforms )
- && ( planeReorderPossible == rhs.planeReorderPossible )
- && ( persistentContent == rhs.persistentContent );
+ memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
}
- bool operator!=( DisplayPropertiesKHR const& rhs ) const
+ DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
+ return *this;
}
- DisplayKHR display;
- const char* displayName;
- Extent2D physicalDimensions;
- Extent2D physicalResolution;
- SurfaceTransformFlagsKHR supportedTransforms;
- Bool32 planeReorderPossible;
- Bool32 persistentContent;
- };
- static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "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_ )
- , displayMode( displayMode_ )
- , planeIndex( planeIndex_ )
- , planeStackIndex( planeStackIndex_ )
- , transform( transform_ )
- , globalAlpha( globalAlpha_ )
- , alphaMode( alphaMode_ )
- , imageExtent( imageExtent_ )
+ DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
{
+ pNext = pNext_;
+ return *this;
}
- DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
{
- memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
+ flags = flags_;
+ return *this;
}
- DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
{
- memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
+ bindingCount = bindingCount_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
+ DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
{
- pNext = pNext_;
+ pBindings = pBindings_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
+ operator const VkDescriptorSetLayoutCreateInfo&() const
{
- flags = flags_;
- return *this;
+ return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
}
- DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
+ bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
{
- displayMode = displayMode_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( bindingCount == rhs.bindingCount )
+ && ( pBindings == rhs.pBindings );
}
- DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
+ bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
{
- planeIndex = planeIndex_;
- return *this;
+ return !operator==( rhs );
}
- DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+ const DescriptorSetLayoutBinding* pBindings;
+ };
+ static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
+
+ enum class ExternalMemoryHandleTypeFlagBitsKHX
+ {
+ eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX,
+ eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX,
+ eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX,
+ eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX,
+ eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX,
+ eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX,
+ eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX
+ };
+
+ using ExternalMemoryHandleTypeFlagsKHX = Flags<ExternalMemoryHandleTypeFlagBitsKHX, VkExternalMemoryHandleTypeFlagsKHX>;
+
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHX operator|( ExternalMemoryHandleTypeFlagBitsKHX bit0, ExternalMemoryHandleTypeFlagBitsKHX bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsKHX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHX operator~( ExternalMemoryHandleTypeFlagBitsKHX bits )
+ {
+ return ~( ExternalMemoryHandleTypeFlagsKHX( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsKHX>
+ {
+ enum
{
- planeStackIndex = planeStackIndex_;
- return *this;
- }
+ allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource)
+ };
+ };
- DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
+ struct PhysicalDeviceExternalImageFormatInfoKHX
+ {
+ PhysicalDeviceExternalImageFormatInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd )
+ : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHX )
+ , pNext( nullptr )
+ , handleType( handleType_ )
{
- transform = transform_;
- return *this;
}
- DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
+ PhysicalDeviceExternalImageFormatInfoKHX( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) );
+ }
+
+ PhysicalDeviceExternalImageFormatInfoKHX& operator=( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs )
{
- globalAlpha = globalAlpha_;
+ memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) );
return *this;
}
- DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
+ PhysicalDeviceExternalImageFormatInfoKHX& setPNext( const void* pNext_ )
{
- alphaMode = alphaMode_;
+ pNext = pNext_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ PhysicalDeviceExternalImageFormatInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ )
{
- imageExtent = imageExtent_;
+ handleType = handleType_;
return *this;
}
- operator const VkDisplaySurfaceCreateInfoKHR&() const
+ operator const VkPhysicalDeviceExternalImageFormatInfoKHX&() const
{
- return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfoKHX*>(this);
}
- bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
+ bool operator==( PhysicalDeviceExternalImageFormatInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( displayMode == rhs.displayMode )
- && ( planeIndex == rhs.planeIndex )
- && ( planeStackIndex == rhs.planeStackIndex )
- && ( transform == rhs.transform )
- && ( globalAlpha == rhs.globalAlpha )
- && ( alphaMode == rhs.alphaMode )
- && ( imageExtent == rhs.imageExtent );
+ && ( handleType == rhs.handleType );
}
- bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
+ bool operator!=( PhysicalDeviceExternalImageFormatInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- DisplaySurfaceCreateFlagsKHR flags;
- DisplayModeKHR displayMode;
- uint32_t planeIndex;
- uint32_t planeStackIndex;
- SurfaceTransformFlagBitsKHR transform;
- float globalAlpha;
- DisplayPlaneAlphaFlagBitsKHR alphaMode;
- Extent2D imageExtent;
+ ExternalMemoryHandleTypeFlagBitsKHX handleType;
};
- static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHX ), "struct and wrapper have different size!" );
- struct SurfaceCapabilitiesKHR
+ struct PhysicalDeviceExternalBufferInfoKHX
{
- operator const VkSurfaceCapabilitiesKHR&() const
+ PhysicalDeviceExternalBufferInfoKHX( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd )
+ : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHX )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , usage( usage_ )
+ , handleType( handleType_ )
{
- return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
}
- bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
+ PhysicalDeviceExternalBufferInfoKHX( VkPhysicalDeviceExternalBufferInfoKHX const & rhs )
{
- return ( minImageCount == rhs.minImageCount )
- && ( maxImageCount == rhs.maxImageCount )
- && ( currentExtent == rhs.currentExtent )
- && ( minImageExtent == rhs.minImageExtent )
- && ( maxImageExtent == rhs.maxImageExtent )
- && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
- && ( supportedTransforms == rhs.supportedTransforms )
- && ( currentTransform == rhs.currentTransform )
- && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
- && ( supportedUsageFlags == rhs.supportedUsageFlags );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) );
}
- bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
+ PhysicalDeviceExternalBufferInfoKHX& operator=( VkPhysicalDeviceExternalBufferInfoKHX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) );
+ return *this;
}
- uint32_t minImageCount;
- uint32_t maxImageCount;
- Extent2D currentExtent;
- Extent2D minImageExtent;
- Extent2D maxImageExtent;
- uint32_t maxImageArrayLayers;
- SurfaceTransformFlagsKHR supportedTransforms;
- SurfaceTransformFlagBitsKHR currentTransform;
- CompositeAlphaFlagsKHR supportedCompositeAlpha;
- ImageUsageFlags supportedUsageFlags;
- };
- static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "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_ )
- , surface( surface_ )
- , minImageCount( minImageCount_ )
- , imageFormat( imageFormat_ )
- , imageColorSpace( imageColorSpace_ )
- , imageExtent( imageExtent_ )
- , imageArrayLayers( imageArrayLayers_ )
- , imageUsage( imageUsage_ )
- , imageSharingMode( imageSharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
- , preTransform( preTransform_ )
- , compositeAlpha( compositeAlpha_ )
- , presentMode( presentMode_ )
- , clipped( clipped_ )
- , oldSwapchain( oldSwapchain_ )
+ PhysicalDeviceExternalBufferInfoKHX& setPNext( const void* pNext_ )
{
+ pNext = pNext_;
+ return *this;
}
- SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
+ PhysicalDeviceExternalBufferInfoKHX& setFlags( BufferCreateFlags flags_ )
{
- memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
+ flags = flags_;
+ return *this;
}
- SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
+ PhysicalDeviceExternalBufferInfoKHX& setUsage( BufferUsageFlags usage_ )
{
- memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
+ usage = usage_;
return *this;
}
- SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
+ PhysicalDeviceExternalBufferInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ )
{
- pNext = pNext_;
+ handleType = handleType_;
return *this;
}
- SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
+ operator const VkPhysicalDeviceExternalBufferInfoKHX&() const
{
- flags = flags_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHX*>(this);
}
- SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
+ bool operator==( PhysicalDeviceExternalBufferInfoKHX const& rhs ) const
{
- surface = surface_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( usage == rhs.usage )
+ && ( handleType == rhs.handleType );
}
- SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
+ bool operator!=( PhysicalDeviceExternalBufferInfoKHX const& rhs ) const
{
- minImageCount = minImageCount_;
- return *this;
+ return !operator==( rhs );
}
- SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ BufferCreateFlags flags;
+ BufferUsageFlags usage;
+ ExternalMemoryHandleTypeFlagBitsKHX handleType;
+ };
+ static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHX ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHX ), "struct and wrapper have different size!" );
+
+ struct ExternalMemoryImageCreateInfoKHX
+ {
+ ExternalMemoryImageCreateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() )
+ : sType( StructureType::eExternalMemoryImageCreateInfoKHX )
+ , pNext( nullptr )
+ , handleTypes( handleTypes_ )
{
- imageFormat = imageFormat_;
- return *this;
}
- SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
+ ExternalMemoryImageCreateInfoKHX( VkExternalMemoryImageCreateInfoKHX const & rhs )
{
- imageColorSpace = imageColorSpace_;
- return *this;
+ memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) );
}
- SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ ExternalMemoryImageCreateInfoKHX& operator=( VkExternalMemoryImageCreateInfoKHX const & rhs )
{
- imageExtent = imageExtent_;
+ memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) );
return *this;
}
- SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
+ ExternalMemoryImageCreateInfoKHX& setPNext( const void* pNext_ )
{
- imageArrayLayers = imageArrayLayers_;
+ pNext = pNext_;
return *this;
}
- SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
+ ExternalMemoryImageCreateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ )
{
- imageUsage = imageUsage_;
+ handleTypes = handleTypes_;
return *this;
}
- SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
+ operator const VkExternalMemoryImageCreateInfoKHX&() const
{
- imageSharingMode = imageSharingMode_;
- return *this;
+ return *reinterpret_cast<const VkExternalMemoryImageCreateInfoKHX*>(this);
}
- SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ bool operator==( ExternalMemoryImageCreateInfoKHX const& rhs ) const
{
- queueFamilyIndexCount = queueFamilyIndexCount_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleTypes == rhs.handleTypes );
}
- SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ bool operator!=( ExternalMemoryImageCreateInfoKHX const& rhs ) const
{
- pQueueFamilyIndices = pQueueFamilyIndices_;
- return *this;
+ return !operator==( rhs );
}
- SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ ExternalMemoryHandleTypeFlagsKHX handleTypes;
+ };
+ static_assert( sizeof( ExternalMemoryImageCreateInfoKHX ) == sizeof( VkExternalMemoryImageCreateInfoKHX ), "struct and wrapper have different size!" );
+
+ struct ExternalMemoryBufferCreateInfoKHX
+ {
+ ExternalMemoryBufferCreateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() )
+ : sType( StructureType::eExternalMemoryBufferCreateInfoKHX )
+ , pNext( nullptr )
+ , handleTypes( handleTypes_ )
{
- preTransform = preTransform_;
- return *this;
}
- SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
+ ExternalMemoryBufferCreateInfoKHX( VkExternalMemoryBufferCreateInfoKHX const & rhs )
{
- compositeAlpha = compositeAlpha_;
- return *this;
+ memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) );
}
- SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
+ ExternalMemoryBufferCreateInfoKHX& operator=( VkExternalMemoryBufferCreateInfoKHX const & rhs )
{
- presentMode = presentMode_;
+ memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) );
return *this;
}
- SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
+ ExternalMemoryBufferCreateInfoKHX& setPNext( const void* pNext_ )
{
- clipped = clipped_;
+ pNext = pNext_;
return *this;
}
- SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
+ ExternalMemoryBufferCreateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ )
{
- oldSwapchain = oldSwapchain_;
+ handleTypes = handleTypes_;
return *this;
}
- operator const VkSwapchainCreateInfoKHR&() const
+ operator const VkExternalMemoryBufferCreateInfoKHX&() const
{
- return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
+ return *reinterpret_cast<const VkExternalMemoryBufferCreateInfoKHX*>(this);
}
- bool operator==( SwapchainCreateInfoKHR const& rhs ) const
+ bool operator==( ExternalMemoryBufferCreateInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( surface == rhs.surface )
- && ( minImageCount == rhs.minImageCount )
- && ( imageFormat == rhs.imageFormat )
- && ( imageColorSpace == rhs.imageColorSpace )
- && ( imageExtent == rhs.imageExtent )
- && ( imageArrayLayers == rhs.imageArrayLayers )
- && ( imageUsage == rhs.imageUsage )
- && ( imageSharingMode == rhs.imageSharingMode )
- && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
- && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
- && ( preTransform == rhs.preTransform )
- && ( compositeAlpha == rhs.compositeAlpha )
- && ( presentMode == rhs.presentMode )
- && ( clipped == rhs.clipped )
- && ( oldSwapchain == rhs.oldSwapchain );
+ && ( handleTypes == rhs.handleTypes );
}
- bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
+ bool operator!=( ExternalMemoryBufferCreateInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- SwapchainCreateFlagsKHR flags;
- SurfaceKHR surface;
- uint32_t minImageCount;
- Format imageFormat;
- ColorSpaceKHR imageColorSpace;
- Extent2D imageExtent;
- uint32_t imageArrayLayers;
- ImageUsageFlags imageUsage;
- SharingMode imageSharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- SurfaceTransformFlagBitsKHR preTransform;
- CompositeAlphaFlagBitsKHR compositeAlpha;
- PresentModeKHR presentMode;
- Bool32 clipped;
- SwapchainKHR oldSwapchain;
- };
- static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
-
- enum class DebugReportFlagBitsEXT
- {
- eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
- eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
- ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
- eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
- eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
- };
-
- using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
-
- VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
- {
- return DebugReportFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
- {
- return ~( DebugReportFlagsEXT( bits ) );
- }
-
- template <> struct FlagTraits<DebugReportFlagBitsEXT>
- {
- enum
- {
- allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
- };
+ ExternalMemoryHandleTypeFlagsKHX handleTypes;
};
+ static_assert( sizeof( ExternalMemoryBufferCreateInfoKHX ) == sizeof( VkExternalMemoryBufferCreateInfoKHX ), "struct and wrapper have different size!" );
- struct DebugReportCallbackCreateInfoEXT
+ struct ExportMemoryAllocateInfoKHX
{
- DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr )
- : sType( StructureType::eDebugReportCallbackCreateInfoEXT )
+ ExportMemoryAllocateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() )
+ : sType( StructureType::eExportMemoryAllocateInfoKHX )
, pNext( nullptr )
- , flags( flags_ )
- , pfnCallback( pfnCallback_ )
- , pUserData( pUserData_ )
- {
- }
-
- DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
- }
-
- DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ , handleTypes( handleTypes_ )
{
- memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
- return *this;
}
- DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
+ ExportMemoryAllocateInfoKHX( VkExportMemoryAllocateInfoKHX const & rhs )
{
- pNext = pNext_;
- return *this;
+ memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) );
}
- DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
+ ExportMemoryAllocateInfoKHX& operator=( VkExportMemoryAllocateInfoKHX const & rhs )
{
- flags = flags_;
+ memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) );
return *this;
}
- DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
+ ExportMemoryAllocateInfoKHX& setPNext( const void* pNext_ )
{
- pfnCallback = pfnCallback_;
+ pNext = pNext_;
return *this;
}
- DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
+ ExportMemoryAllocateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ )
{
- pUserData = pUserData_;
+ handleTypes = handleTypes_;
return *this;
}
- operator const VkDebugReportCallbackCreateInfoEXT&() const
+ operator const VkExportMemoryAllocateInfoKHX&() const
{
- return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
+ return *reinterpret_cast<const VkExportMemoryAllocateInfoKHX*>(this);
}
- bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
+ bool operator==( ExportMemoryAllocateInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( pfnCallback == rhs.pfnCallback )
- && ( pUserData == rhs.pUserData );
+ && ( handleTypes == rhs.handleTypes );
}
- bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
+ bool operator!=( ExportMemoryAllocateInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- DebugReportFlagsEXT flags;
- PFN_vkDebugReportCallbackEXT pfnCallback;
- void* pUserData;
- };
- static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
-
- enum class DebugReportObjectTypeEXT
- {
- eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
- eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
- ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
- eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
- eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
- eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
- eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
- eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
- eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
- eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
- eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
- eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
- eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
- eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
- eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
- eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
- ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
- ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
- eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
- ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
- eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
- eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
- eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
- eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
- eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
- eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
- eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
- eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
- eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
- eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
- eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
- eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
- eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT
+ ExternalMemoryHandleTypeFlagsKHX handleTypes;
};
+ static_assert( sizeof( ExportMemoryAllocateInfoKHX ) == sizeof( VkExportMemoryAllocateInfoKHX ), "struct and wrapper have different size!" );
- struct DebugMarkerObjectNameInfoEXT
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct ImportMemoryWin32HandleInfoKHX
{
- DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr )
- : sType( StructureType::eDebugMarkerObjectNameInfoEXT )
+ ImportMemoryWin32HandleInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd, HANDLE handle_ = 0 )
+ : sType( StructureType::eImportMemoryWin32HandleInfoKHX )
, pNext( nullptr )
- , objectType( objectType_ )
- , object( object_ )
- , pObjectName( pObjectName_ )
+ , handleType( handleType_ )
+ , handle( handle_ )
{
}
- DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ ImportMemoryWin32HandleInfoKHX( VkImportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
+ memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) );
}
- DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ ImportMemoryWin32HandleInfoKHX& operator=( VkImportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
+ memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) );
return *this;
}
- DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
+ ImportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
- {
- objectType = objectType_;
- return *this;
- }
-
- DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
+ ImportMemoryWin32HandleInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ )
{
- object = object_;
+ handleType = handleType_;
return *this;
}
- DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
+ ImportMemoryWin32HandleInfoKHX& setHandle( HANDLE handle_ )
{
- pObjectName = pObjectName_;
+ handle = handle_;
return *this;
}
- operator const VkDebugMarkerObjectNameInfoEXT&() const
+ operator const VkImportMemoryWin32HandleInfoKHX&() const
{
- return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
+ return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHX*>(this);
}
- bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
+ bool operator==( ImportMemoryWin32HandleInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectType == rhs.objectType )
- && ( object == rhs.object )
- && ( pObjectName == rhs.pObjectName );
+ && ( handleType == rhs.handleType )
+ && ( handle == rhs.handle );
}
- bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
+ bool operator!=( ImportMemoryWin32HandleInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- DebugReportObjectTypeEXT objectType;
- uint64_t object;
- const char* pObjectName;
+ ExternalMemoryHandleTypeFlagBitsKHX handleType;
+ HANDLE handle;
};
- static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportMemoryWin32HandleInfoKHX ) == sizeof( VkImportMemoryWin32HandleInfoKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct DebugMarkerObjectTagInfoEXT
+ struct ImportMemoryFdInfoKHX
{
- DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr )
- : sType( StructureType::eDebugMarkerObjectTagInfoEXT )
+ ImportMemoryFdInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd, int fd_ = 0 )
+ : sType( StructureType::eImportMemoryFdInfoKHX )
, pNext( nullptr )
- , objectType( objectType_ )
- , object( object_ )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
+ , handleType( handleType_ )
+ , fd( fd_ )
{
}
- DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ ImportMemoryFdInfoKHX( VkImportMemoryFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
+ memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) );
}
- DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ ImportMemoryFdInfoKHX& operator=( VkImportMemoryFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
+ memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) );
return *this;
}
- DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
+ ImportMemoryFdInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
- {
- objectType = objectType_;
- return *this;
- }
-
- DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
- {
- object = object_;
- return *this;
- }
-
- DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
- {
- tagName = tagName_;
- return *this;
- }
-
- DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
+ ImportMemoryFdInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ )
{
- tagSize = tagSize_;
+ handleType = handleType_;
return *this;
}
- DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
+ ImportMemoryFdInfoKHX& setFd( int fd_ )
{
- pTag = pTag_;
+ fd = fd_;
return *this;
}
- operator const VkDebugMarkerObjectTagInfoEXT&() const
+ operator const VkImportMemoryFdInfoKHX&() const
{
- return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
+ return *reinterpret_cast<const VkImportMemoryFdInfoKHX*>(this);
}
- bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
+ bool operator==( ImportMemoryFdInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectType == rhs.objectType )
- && ( object == rhs.object )
- && ( tagName == rhs.tagName )
- && ( tagSize == rhs.tagSize )
- && ( pTag == rhs.pTag );
+ && ( handleType == rhs.handleType )
+ && ( fd == rhs.fd );
}
- bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
+ bool operator!=( ImportMemoryFdInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- DebugReportObjectTypeEXT objectType;
- uint64_t object;
- uint64_t tagName;
- size_t tagSize;
- const void* pTag;
+ ExternalMemoryHandleTypeFlagBitsKHX handleType;
+ int fd;
};
- static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportMemoryFdInfoKHX ) == sizeof( VkImportMemoryFdInfoKHX ), "struct and wrapper have different size!" );
- enum class DebugReportErrorEXT
+ enum class ExternalMemoryFeatureFlagBitsKHX
{
- eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT,
- eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT
+ eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX,
+ eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX,
+ eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX
};
- enum class RasterizationOrderAMD
+ using ExternalMemoryFeatureFlagsKHX = Flags<ExternalMemoryFeatureFlagBitsKHX, VkExternalMemoryFeatureFlagsKHX>;
+
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHX operator|( ExternalMemoryFeatureFlagBitsKHX bit0, ExternalMemoryFeatureFlagBitsKHX bit1 )
{
- eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
- eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
+ return ExternalMemoryFeatureFlagsKHX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHX operator~( ExternalMemoryFeatureFlagBitsKHX bits )
+ {
+ return ~( ExternalMemoryFeatureFlagsKHX( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsKHX>
+ {
+ enum
+ {
+ allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHX::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHX::eImportable)
+ };
};
- struct PipelineRasterizationStateRasterizationOrderAMD
+ struct ExternalMemoryPropertiesKHX
{
- PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
- : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD )
- , pNext( nullptr )
- , rasterizationOrder( rasterizationOrder_ )
+ operator const VkExternalMemoryPropertiesKHX&() const
{
+ return *reinterpret_cast<const VkExternalMemoryPropertiesKHX*>(this);
}
- PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ bool operator==( ExternalMemoryPropertiesKHX const& rhs ) const
{
- memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
+ return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
}
- PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ bool operator!=( ExternalMemoryPropertiesKHX const& rhs ) const
{
- memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
- return *this;
+ return !operator==( rhs );
}
- PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
+ ExternalMemoryFeatureFlagsKHX externalMemoryFeatures;
+ ExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes;
+ ExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes;
+ };
+ static_assert( sizeof( ExternalMemoryPropertiesKHX ) == sizeof( VkExternalMemoryPropertiesKHX ), "struct and wrapper have different size!" );
+
+ struct ExternalImageFormatPropertiesKHX
+ {
+ operator const VkExternalImageFormatPropertiesKHX&() const
{
- pNext = pNext_;
- return *this;
+ return *reinterpret_cast<const VkExternalImageFormatPropertiesKHX*>(this);
}
- PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
+ bool operator==( ExternalImageFormatPropertiesKHX const& rhs ) const
{
- rasterizationOrder = rasterizationOrder_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( externalMemoryProperties == rhs.externalMemoryProperties );
}
- operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
+ bool operator!=( ExternalImageFormatPropertiesKHX const& rhs ) const
{
- return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
+ return !operator==( rhs );
}
- bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ ExternalMemoryPropertiesKHX externalMemoryProperties;
+ };
+ static_assert( sizeof( ExternalImageFormatPropertiesKHX ) == sizeof( VkExternalImageFormatPropertiesKHX ), "struct and wrapper have different size!" );
+
+ struct ExternalBufferPropertiesKHX
+ {
+ operator const VkExternalBufferPropertiesKHX&() const
+ {
+ return *reinterpret_cast<const VkExternalBufferPropertiesKHX*>(this);
+ }
+
+ bool operator==( ExternalBufferPropertiesKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( rasterizationOrder == rhs.rasterizationOrder );
+ && ( externalMemoryProperties == rhs.externalMemoryProperties );
}
- bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+ bool operator!=( ExternalBufferPropertiesKHX const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- const void* pNext;
- RasterizationOrderAMD rasterizationOrder;
+ void* pNext;
+ ExternalMemoryPropertiesKHX externalMemoryProperties;
};
- static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExternalBufferPropertiesKHX ) == sizeof( VkExternalBufferPropertiesKHX ), "struct and wrapper have different size!" );
- enum class ExternalMemoryHandleTypeFlagBitsNV
+ enum class ExternalSemaphoreHandleTypeFlagBitsKHX
{
- eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
- eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
- eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
- eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
+ eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX,
+ eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX,
+ eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX,
+ eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX,
+ eFenceFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX
};
- using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
+ using ExternalSemaphoreHandleTypeFlagsKHX = Flags<ExternalSemaphoreHandleTypeFlagBitsKHX, VkExternalSemaphoreHandleTypeFlagsKHX>;
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHX operator|( ExternalSemaphoreHandleTypeFlagBitsKHX bit0, ExternalSemaphoreHandleTypeFlagBitsKHX bit1 )
{
- return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
+ return ExternalSemaphoreHandleTypeFlagsKHX( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
+ VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHX operator~( ExternalSemaphoreHandleTypeFlagBitsKHX bits )
{
- return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
+ return ~( ExternalSemaphoreHandleTypeFlagsKHX( bits ) );
}
- template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
+ template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBitsKHX>
{
enum
{
- allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
+ allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd)
};
};
- struct ExternalMemoryImageCreateInfoNV
+ struct PhysicalDeviceExternalSemaphoreInfoKHX
{
- ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : sType( StructureType::eExternalMemoryImageCreateInfoNV )
+ PhysicalDeviceExternalSemaphoreInfoKHX( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd )
+ : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHX )
, pNext( nullptr )
- , handleTypes( handleTypes_ )
+ , handleType( handleType_ )
{
}
- ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
+ PhysicalDeviceExternalSemaphoreInfoKHX( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) );
}
- ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
+ PhysicalDeviceExternalSemaphoreInfoKHX& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
+ memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) );
return *this;
}
- ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
+ PhysicalDeviceExternalSemaphoreInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ PhysicalDeviceExternalSemaphoreInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ )
{
- handleTypes = handleTypes_;
+ handleType = handleType_;
return *this;
}
- operator const VkExternalMemoryImageCreateInfoNV&() const
+ operator const VkPhysicalDeviceExternalSemaphoreInfoKHX&() const
{
- return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHX*>(this);
}
- bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
+ bool operator==( PhysicalDeviceExternalSemaphoreInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
+ bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- ExternalMemoryHandleTypeFlagsNV handleTypes;
+ ExternalSemaphoreHandleTypeFlagBitsKHX handleType;
};
- static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHX ), "struct and wrapper have different size!" );
- struct ExportMemoryAllocateInfoNV
+ struct ExportSemaphoreCreateInfoKHX
{
- ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : sType( StructureType::eExportMemoryAllocateInfoNV )
+ ExportSemaphoreCreateInfoKHX( ExternalSemaphoreHandleTypeFlagsKHX handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHX() )
+ : sType( StructureType::eExportSemaphoreCreateInfoKHX )
, pNext( nullptr )
, handleTypes( handleTypes_ )
{
}
- ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
+ ExportSemaphoreCreateInfoKHX( VkExportSemaphoreCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
+ memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) );
}
- ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
+ ExportSemaphoreCreateInfoKHX& operator=( VkExportSemaphoreCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
+ memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) );
return *this;
}
- ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
+ ExportSemaphoreCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ ExportSemaphoreCreateInfoKHX& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHX handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
}
- operator const VkExportMemoryAllocateInfoNV&() const
+ operator const VkExportSemaphoreCreateInfoKHX&() const
{
- return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
+ return *reinterpret_cast<const VkExportSemaphoreCreateInfoKHX*>(this);
}
- bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
+ bool operator==( ExportSemaphoreCreateInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( handleTypes == rhs.handleTypes );
}
- bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
+ bool operator!=( ExportSemaphoreCreateInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- ExternalMemoryHandleTypeFlagsNV handleTypes;
+ ExternalSemaphoreHandleTypeFlagsKHX handleTypes;
};
- static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExportSemaphoreCreateInfoKHX ) == sizeof( VkExportSemaphoreCreateInfoKHX ), "struct and wrapper have different size!" );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportMemoryWin32HandleInfoNV
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ struct ImportSemaphoreWin32HandleInfoKHX
{
- ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
- : sType( StructureType::eImportMemoryWin32HandleInfoNV )
+ ImportSemaphoreWin32HandleInfoKHX( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagsKHX handleType_ = ExternalSemaphoreHandleTypeFlagsKHX(), HANDLE handle_ = 0 )
+ : sType( StructureType::eImportSemaphoreWin32HandleInfoKHX )
, pNext( nullptr )
+ , semaphore( semaphore_ )
, handleType( handleType_ )
, handle( handle_ )
{
}
- ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
+ ImportSemaphoreWin32HandleInfoKHX( VkImportSemaphoreWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
+ memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) );
}
- ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
+ ImportSemaphoreWin32HandleInfoKHX& operator=( VkImportSemaphoreWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
+ memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) );
return *this;
}
- ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
+ ImportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
+ ImportSemaphoreWin32HandleInfoKHX& setSemaphore( Semaphore semaphore_ )
+ {
+ semaphore = semaphore_;
+ return *this;
+ }
+
+ ImportSemaphoreWin32HandleInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagsKHX handleType_ )
{
handleType = handleType_;
return *this;
}
- ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
+ ImportSemaphoreWin32HandleInfoKHX& setHandle( HANDLE handle_ )
{
handle = handle_;
return *this;
}
- operator const VkImportMemoryWin32HandleInfoNV&() const
+ operator const VkImportSemaphoreWin32HandleInfoKHX&() const
{
- return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
+ return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHX*>(this);
}
- bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
+ bool operator==( ImportSemaphoreWin32HandleInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
+ && ( semaphore == rhs.semaphore )
&& ( handleType == rhs.handleType )
&& ( handle == rhs.handle );
}
- bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
+ bool operator!=( ImportSemaphoreWin32HandleInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- ExternalMemoryHandleTypeFlagsNV handleType;
+ Semaphore semaphore;
+ ExternalSemaphoreHandleTypeFlagsKHX handleType;
HANDLE handle;
};
- static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- enum class ExternalMemoryFeatureFlagBitsNV
- {
- eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
- eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
- eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
- };
-
- using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
-
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
- {
- return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
- {
- return ~( ExternalMemoryFeatureFlagsNV( bits ) );
- }
-
- template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
- {
- enum
- {
- allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
- };
- };
+ static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHX ) == sizeof( VkImportSemaphoreWin32HandleInfoKHX ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
- struct ExternalImageFormatPropertiesNV
+ struct ImportSemaphoreFdInfoKHX
{
- operator const VkExternalImageFormatPropertiesNV&() const
- {
- return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
- }
-
- bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
- {
- return ( imageFormatProperties == rhs.imageFormatProperties )
- && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
- && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
- && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
- }
-
- bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
+ ImportSemaphoreFdInfoKHX( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd, int fd_ = 0 )
+ : sType( StructureType::eImportSemaphoreFdInfoKHX )
+ , pNext( nullptr )
+ , semaphore( semaphore_ )
+ , handleType( handleType_ )
+ , fd( fd_ )
{
- return !operator==( rhs );
}
- ImageFormatProperties imageFormatProperties;
- ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
- ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
- ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
- };
- static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
-
- enum class ValidationCheckEXT
- {
- eAll = VK_VALIDATION_CHECK_ALL_EXT
- };
-
- struct ValidationFlagsEXT
- {
- ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
- : sType( StructureType::eValidationFlagsEXT )
- , pNext( nullptr )
- , disabledValidationCheckCount( disabledValidationCheckCount_ )
- , pDisabledValidationChecks( pDisabledValidationChecks_ )
+ ImportSemaphoreFdInfoKHX( VkImportSemaphoreFdInfoKHX const & rhs )
{
+ memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) );
}
- ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
+ ImportSemaphoreFdInfoKHX& operator=( VkImportSemaphoreFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
+ memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) );
+ return *this;
}
- ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
+ ImportSemaphoreFdInfoKHX& setPNext( const void* pNext_ )
{
- memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
+ pNext = pNext_;
return *this;
}
- ValidationFlagsEXT& setPNext( const void* pNext_ )
+ ImportSemaphoreFdInfoKHX& setSemaphore( Semaphore semaphore_ )
{
- pNext = pNext_;
+ semaphore = semaphore_;
return *this;
}
- ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
+ ImportSemaphoreFdInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ )
{
- disabledValidationCheckCount = disabledValidationCheckCount_;
+ handleType = handleType_;
return *this;
}
- ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ )
+ ImportSemaphoreFdInfoKHX& setFd( int fd_ )
{
- pDisabledValidationChecks = pDisabledValidationChecks_;
+ fd = fd_;
return *this;
}
- operator const VkValidationFlagsEXT&() const
+ operator const VkImportSemaphoreFdInfoKHX&() const
{
- return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
+ return *reinterpret_cast<const VkImportSemaphoreFdInfoKHX*>(this);
}
- bool operator==( ValidationFlagsEXT const& rhs ) const
+ bool operator==( ImportSemaphoreFdInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
- && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+ && ( semaphore == rhs.semaphore )
+ && ( handleType == rhs.handleType )
+ && ( fd == rhs.fd );
}
- bool operator!=( ValidationFlagsEXT const& rhs ) const
+ bool operator!=( ImportSemaphoreFdInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- uint32_t disabledValidationCheckCount;
- ValidationCheckEXT* pDisabledValidationChecks;
+ Semaphore semaphore;
+ ExternalSemaphoreHandleTypeFlagBitsKHX handleType;
+ int fd;
};
- static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportSemaphoreFdInfoKHX ) == sizeof( VkImportSemaphoreFdInfoKHX ), "struct and wrapper have different size!" );
- enum class IndirectCommandsLayoutUsageFlagBitsNVX
+ enum class ExternalSemaphoreFeatureFlagBitsKHX
{
- eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
- eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
- eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
- eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
+ eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX,
+ eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX
};
- using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
+ using ExternalSemaphoreFeatureFlagsKHX = Flags<ExternalSemaphoreFeatureFlagBitsKHX, VkExternalSemaphoreFeatureFlagsKHX>;
- VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHX operator|( ExternalSemaphoreFeatureFlagBitsKHX bit0, ExternalSemaphoreFeatureFlagBitsKHX bit1 )
{
- return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
+ return ExternalSemaphoreFeatureFlagsKHX( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
+ VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHX operator~( ExternalSemaphoreFeatureFlagBitsKHX bits )
{
- return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
+ return ~( ExternalSemaphoreFeatureFlagsKHX( bits ) );
}
- template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
+ template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBitsKHX>
{
enum
{
- allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
+ allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHX::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHX::eImportable)
};
};
- enum class ObjectEntryUsageFlagBitsNVX
+ struct ExternalSemaphorePropertiesKHX
{
- eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
- eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
+ operator const VkExternalSemaphorePropertiesKHX&() const
+ {
+ return *reinterpret_cast<const VkExternalSemaphorePropertiesKHX*>(this);
+ }
+
+ bool operator==( ExternalSemaphorePropertiesKHX const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
+ && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
+ }
+
+ bool operator!=( ExternalSemaphorePropertiesKHX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ ExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes;
+ ExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes;
+ ExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures;
};
+ static_assert( sizeof( ExternalSemaphorePropertiesKHX ) == sizeof( VkExternalSemaphorePropertiesKHX ), "struct and wrapper have different size!" );
- using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
+ enum class SurfaceCounterFlagBitsEXT
+ {
+ eVblankExt = VK_SURFACE_COUNTER_VBLANK_EXT
+ };
- VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
+
+ VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
{
- return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
+ return SurfaceCounterFlagsEXT( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
+ VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
{
- return ~( ObjectEntryUsageFlagsNVX( bits ) );
+ return ~( SurfaceCounterFlagsEXT( bits ) );
}
- template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
+ template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
{
enum
{
- allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
+ allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblankExt)
};
};
- enum class IndirectCommandsTokenTypeNVX
+ struct SurfaceCapabilities2EXT
{
- eVkIndirectCommandsTokenPipeline = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX,
- eVkIndirectCommandsTokenDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX,
- eVkIndirectCommandsTokenIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX,
- eVkIndirectCommandsTokenVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX,
- eVkIndirectCommandsTokenPushConstant = VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX,
- eVkIndirectCommandsTokenDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX,
- eVkIndirectCommandsTokenDraw = VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX,
- eVkIndirectCommandsTokenDispatch = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX
- };
+ operator const VkSurfaceCapabilities2EXT&() const
+ {
+ return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
+ }
- struct IndirectCommandsTokenNVX
- {
- IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 )
- : tokenType( tokenType_ )
- , buffer( buffer_ )
- , offset( offset_ )
+ bool operator==( SurfaceCapabilities2EXT const& rhs ) const
{
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( minImageCount == rhs.minImageCount )
+ && ( maxImageCount == rhs.maxImageCount )
+ && ( currentExtent == rhs.currentExtent )
+ && ( minImageExtent == rhs.minImageExtent )
+ && ( maxImageExtent == rhs.maxImageExtent )
+ && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+ && ( supportedTransforms == rhs.supportedTransforms )
+ && ( currentTransform == rhs.currentTransform )
+ && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
+ && ( supportedUsageFlags == rhs.supportedUsageFlags )
+ && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
}
- IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
+ bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
{
- memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) );
+ return !operator==( rhs );
}
- IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ Extent2D currentExtent;
+ Extent2D minImageExtent;
+ Extent2D maxImageExtent;
+ uint32_t maxImageArrayLayers;
+ SurfaceTransformFlagsKHR supportedTransforms;
+ SurfaceTransformFlagBitsKHR currentTransform;
+ CompositeAlphaFlagsKHR supportedCompositeAlpha;
+ ImageUsageFlags supportedUsageFlags;
+ SurfaceCounterFlagsEXT supportedSurfaceCounters;
+ };
+ static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
+
+ struct SwapchainCounterCreateInfoEXT
+ {
+ SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
+ : sType( StructureType::eSwapchainCounterCreateInfoEXT )
+ , pNext( nullptr )
+ , surfaceCounters( surfaceCounters_ )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) );
- return *this;
}
- IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
{
- tokenType = tokenType_;
+ memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) );
+ }
+
+ SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) );
return *this;
}
- IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ )
+ SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
{
- buffer = buffer_;
+ pNext = pNext_;
return *this;
}
- IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ )
+ SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
{
- offset = offset_;
+ surfaceCounters = surfaceCounters_;
return *this;
}
- operator const VkIndirectCommandsTokenNVX&() const
+ operator const VkSwapchainCounterCreateInfoEXT&() const
{
- return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
+ return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
}
- bool operator==( IndirectCommandsTokenNVX const& rhs ) const
+ bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
{
- return ( tokenType == rhs.tokenType )
- && ( buffer == rhs.buffer )
- && ( offset == rhs.offset );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( surfaceCounters == rhs.surfaceCounters );
}
- bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
+ bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
- IndirectCommandsTokenTypeNVX tokenType;
- Buffer buffer;
- DeviceSize offset;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ SurfaceCounterFlagsEXT surfaceCounters;
};
- static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
- struct IndirectCommandsLayoutTokenNVX
+ enum class DisplayPowerStateEXT
{
- IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 )
- : tokenType( tokenType_ )
- , bindingUnit( bindingUnit_ )
- , dynamicCount( dynamicCount_ )
- , divisor( divisor_ )
- {
- }
-
- IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) );
- }
+ eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
+ eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
+ eOn = VK_DISPLAY_POWER_STATE_ON_EXT
+ };
- IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
+ struct DisplayPowerInfoEXT
+ {
+ DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
+ : sType( StructureType::eDisplayPowerInfoEXT )
+ , pNext( nullptr )
+ , powerState( powerState_ )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) );
- return *this;
}
- IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
{
- tokenType = tokenType_;
- return *this;
+ memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) );
}
- IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ )
+ DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
{
- bindingUnit = bindingUnit_;
+ memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) );
return *this;
}
- IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ )
+ DisplayPowerInfoEXT& setPNext( const void* pNext_ )
{
- dynamicCount = dynamicCount_;
+ pNext = pNext_;
return *this;
}
- IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ )
+ DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ )
{
- divisor = divisor_;
+ powerState = powerState_;
return *this;
}
- operator const VkIndirectCommandsLayoutTokenNVX&() const
+ operator const VkDisplayPowerInfoEXT&() const
{
- return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
+ return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
}
- bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
+ bool operator==( DisplayPowerInfoEXT const& rhs ) const
{
- return ( tokenType == rhs.tokenType )
- && ( bindingUnit == rhs.bindingUnit )
- && ( dynamicCount == rhs.dynamicCount )
- && ( divisor == rhs.divisor );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( powerState == rhs.powerState );
}
- bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
+ bool operator!=( DisplayPowerInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
- IndirectCommandsTokenTypeNVX tokenType;
- uint32_t bindingUnit;
- uint32_t dynamicCount;
- uint32_t divisor;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DisplayPowerStateEXT powerState;
};
- static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
- struct IndirectCommandsLayoutCreateInfoNVX
+ enum class DeviceEventTypeEXT
{
- IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
- : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX )
+ eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
+ };
+
+ struct DeviceEventInfoEXT
+ {
+ DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
+ : sType( StructureType::eDeviceEventInfoEXT )
, pNext( nullptr )
- , pipelineBindPoint( pipelineBindPoint_ )
- , flags( flags_ )
- , tokenCount( tokenCount_ )
- , pTokens( pTokens_ )
+ , deviceEvent( deviceEvent_ )
{
}
- IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+ DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) );
}
- IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+ DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) );
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
+ DeviceEventInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
- {
- pipelineBindPoint = pipelineBindPoint_;
- return *this;
- }
-
- IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ )
- {
- tokenCount = tokenCount_;
- return *this;
- }
-
- IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
+ DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
{
- pTokens = pTokens_;
+ deviceEvent = deviceEvent_;
return *this;
}
- operator const VkIndirectCommandsLayoutCreateInfoNVX&() const
+ operator const VkDeviceEventInfoEXT&() const
{
- return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
+ return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
}
- bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
+ bool operator==( DeviceEventInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( pipelineBindPoint == rhs.pipelineBindPoint )
- && ( flags == rhs.flags )
- && ( tokenCount == rhs.tokenCount )
- && ( pTokens == rhs.pTokens );
+ && ( deviceEvent == rhs.deviceEvent );
}
- bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
+ bool operator!=( DeviceEventInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- PipelineBindPoint pipelineBindPoint;
- IndirectCommandsLayoutUsageFlagsNVX flags;
- uint32_t tokenCount;
- const IndirectCommandsLayoutTokenNVX* pTokens;
+ DeviceEventTypeEXT deviceEvent;
};
- static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
- enum class ObjectEntryTypeNVX
+ enum class DisplayEventTypeEXT
{
- eVkObjectEntryDescriptorSet = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX,
- eVkObjectEntryPipeline = VK_OBJECT_ENTRY_PIPELINE_NVX,
- eVkObjectEntryIndexBuffer = VK_OBJECT_ENTRY_INDEX_BUFFER_NVX,
- eVkObjectEntryVertexBuffer = VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX,
- eVkObjectEntryPushConstant = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX
+ eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
};
- struct ObjectTableCreateInfoNVX
+ struct DisplayEventInfoEXT
{
- 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 )
+ DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
+ : sType( StructureType::eDisplayEventInfoEXT )
, pNext( nullptr )
- , objectCount( objectCount_ )
- , pObjectEntryTypes( pObjectEntryTypes_ )
- , pObjectEntryCounts( pObjectEntryCounts_ )
- , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
- , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
- , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
- , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
- , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
- , maxPipelineLayouts( maxPipelineLayouts_ )
+ , displayEvent( displayEvent_ )
{
}
- ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
+ DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) );
}
- ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
+ DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) );
return *this;
}
- ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
+ DisplayEventInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ )
+ DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
{
- objectCount = objectCount_;
+ displayEvent = displayEvent_;
return *this;
}
- ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
+ operator const VkDisplayEventInfoEXT&() const
{
- pObjectEntryTypes = pObjectEntryTypes_;
- return *this;
+ return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
}
- ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
+ bool operator==( DisplayEventInfoEXT const& rhs ) const
{
- pObjectEntryCounts = pObjectEntryCounts_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( displayEvent == rhs.displayEvent );
+ }
+
+ bool operator!=( DisplayEventInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
}
- ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DisplayEventTypeEXT displayEvent;
+ };
+ static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
+
+ enum class PeerMemoryFeatureFlagBitsKHX
+ {
+ eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX,
+ eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX,
+ eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX,
+ eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX
+ };
+
+ using PeerMemoryFeatureFlagsKHX = Flags<PeerMemoryFeatureFlagBitsKHX, VkPeerMemoryFeatureFlagsKHX>;
+
+ VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX operator|( PeerMemoryFeatureFlagBitsKHX bit0, PeerMemoryFeatureFlagBitsKHX bit1 )
+ {
+ return PeerMemoryFeatureFlagsKHX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX operator~( PeerMemoryFeatureFlagBitsKHX bits )
+ {
+ return ~( PeerMemoryFeatureFlagsKHX( bits ) );
+ }
+
+ template <> struct FlagTraits<PeerMemoryFeatureFlagBitsKHX>
+ {
+ enum
+ {
+ allFlags = VkFlags(PeerMemoryFeatureFlagBitsKHX::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eGenericDst)
+ };
+ };
+
+ enum class MemoryAllocateFlagBitsKHX
+ {
+ eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX
+ };
+
+ using MemoryAllocateFlagsKHX = Flags<MemoryAllocateFlagBitsKHX, VkMemoryAllocateFlagsKHX>;
+
+ VULKAN_HPP_INLINE MemoryAllocateFlagsKHX operator|( MemoryAllocateFlagBitsKHX bit0, MemoryAllocateFlagBitsKHX bit1 )
+ {
+ return MemoryAllocateFlagsKHX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE MemoryAllocateFlagsKHX operator~( MemoryAllocateFlagBitsKHX bits )
+ {
+ return ~( MemoryAllocateFlagsKHX( bits ) );
+ }
+
+ template <> struct FlagTraits<MemoryAllocateFlagBitsKHX>
+ {
+ enum
+ {
+ allFlags = VkFlags(MemoryAllocateFlagBitsKHX::eDeviceMask)
+ };
+ };
+
+ struct MemoryAllocateFlagsInfoKHX
+ {
+ MemoryAllocateFlagsInfoKHX( MemoryAllocateFlagsKHX flags_ = MemoryAllocateFlagsKHX(), uint32_t deviceMask_ = 0 )
+ : sType( StructureType::eMemoryAllocateFlagsInfoKHX )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , deviceMask( deviceMask_ )
{
- pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
- return *this;
}
- ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
+ MemoryAllocateFlagsInfoKHX( VkMemoryAllocateFlagsInfoKHX const & rhs )
{
- maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
- return *this;
+ memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) );
}
- ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
+ MemoryAllocateFlagsInfoKHX& operator=( VkMemoryAllocateFlagsInfoKHX const & rhs )
{
- maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
+ memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) );
return *this;
}
- ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
+ MemoryAllocateFlagsInfoKHX& setPNext( const void* pNext_ )
{
- maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
+ pNext = pNext_;
return *this;
}
- ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
+ MemoryAllocateFlagsInfoKHX& setFlags( MemoryAllocateFlagsKHX flags_ )
{
- maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
+ flags = flags_;
return *this;
}
- ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
+ MemoryAllocateFlagsInfoKHX& setDeviceMask( uint32_t deviceMask_ )
{
- maxPipelineLayouts = maxPipelineLayouts_;
+ deviceMask = deviceMask_;
return *this;
}
- operator const VkObjectTableCreateInfoNVX&() const
+ operator const VkMemoryAllocateFlagsInfoKHX&() const
{
- return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
+ return *reinterpret_cast<const VkMemoryAllocateFlagsInfoKHX*>(this);
}
- bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
+ bool operator==( MemoryAllocateFlagsInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectCount == rhs.objectCount )
- && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
- && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
- && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
- && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
- && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
- && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
- && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
- && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
+ && ( flags == rhs.flags )
+ && ( deviceMask == rhs.deviceMask );
}
- bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
+ bool operator!=( MemoryAllocateFlagsInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- uint32_t objectCount;
- const ObjectEntryTypeNVX* pObjectEntryTypes;
- const uint32_t* pObjectEntryCounts;
- const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
- uint32_t maxUniformBuffersPerDescriptor;
- uint32_t maxStorageBuffersPerDescriptor;
- uint32_t maxStorageImagesPerDescriptor;
- uint32_t maxSampledImagesPerDescriptor;
- uint32_t maxPipelineLayouts;
+ MemoryAllocateFlagsKHX flags;
+ uint32_t deviceMask;
};
- static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryAllocateFlagsInfoKHX ) == sizeof( VkMemoryAllocateFlagsInfoKHX ), "struct and wrapper have different size!" );
- struct ObjectTableEntryNVX
+ enum class DeviceGroupPresentModeFlagBitsKHX
{
- ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
- : type( type_ )
- , flags( flags_ )
- {
- }
+ eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX,
+ eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX,
+ eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX,
+ eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX
+ };
- ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) );
- }
+ using DeviceGroupPresentModeFlagsKHX = Flags<DeviceGroupPresentModeFlagBitsKHX, VkDeviceGroupPresentModeFlagsKHX>;
- ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) );
- return *this;
- }
+ VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHX operator|( DeviceGroupPresentModeFlagBitsKHX bit0, DeviceGroupPresentModeFlagBitsKHX bit1 )
+ {
+ return DeviceGroupPresentModeFlagsKHX( bit0 ) | bit1;
+ }
- ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
- {
- type = type_;
- return *this;
- }
+ VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHX operator~( DeviceGroupPresentModeFlagBitsKHX bits )
+ {
+ return ~( DeviceGroupPresentModeFlagsKHX( bits ) );
+ }
- ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHX>
+ {
+ enum
{
- flags = flags_;
- return *this;
- }
+ allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHX::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice)
+ };
+ };
- operator const VkObjectTableEntryNVX&() const
+ struct DeviceGroupPresentCapabilitiesKHX
+ {
+ operator const VkDeviceGroupPresentCapabilitiesKHX&() const
{
- return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
+ return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHX*>(this);
}
- bool operator==( ObjectTableEntryNVX const& rhs ) const
+ bool operator==( DeviceGroupPresentCapabilitiesKHX const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE_KHX * sizeof( uint32_t ) ) == 0 )
+ && ( modes == rhs.modes );
}
- bool operator!=( ObjectTableEntryNVX const& rhs ) const
+ bool operator!=( DeviceGroupPresentCapabilitiesKHX const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
+ DeviceGroupPresentModeFlagsKHX modes;
};
- static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupPresentCapabilitiesKHX ) == sizeof( VkDeviceGroupPresentCapabilitiesKHX ), "struct and wrapper have different size!" );
- struct ObjectTablePipelineEntryNVX
+ struct DeviceGroupPresentInfoKHX
{
- ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() )
- : type( type_ )
- , flags( flags_ )
- , pipeline( pipeline_ )
+ DeviceGroupPresentInfoKHX( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, DeviceGroupPresentModeFlagBitsKHX mode_ = DeviceGroupPresentModeFlagBitsKHX::eLocal )
+ : sType( StructureType::eDeviceGroupPresentInfoKHX )
+ , pNext( nullptr )
+ , swapchainCount( swapchainCount_ )
+ , pDeviceMasks( pDeviceMasks_ )
+ , mode( mode_ )
{
}
- ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
+ DeviceGroupPresentInfoKHX( VkDeviceGroupPresentInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) );
+ memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) );
}
- ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
+ DeviceGroupPresentInfoKHX& operator=( VkDeviceGroupPresentInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) );
+ memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) );
return *this;
}
- ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ DeviceGroupPresentInfoKHX& setPNext( const void* pNext_ )
{
- type = type_;
+ pNext = pNext_;
return *this;
}
- ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ DeviceGroupPresentInfoKHX& setSwapchainCount( uint32_t swapchainCount_ )
{
- flags = flags_;
+ swapchainCount = swapchainCount_;
return *this;
}
- ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ )
+ DeviceGroupPresentInfoKHX& setPDeviceMasks( const uint32_t* pDeviceMasks_ )
{
- pipeline = pipeline_;
+ pDeviceMasks = pDeviceMasks_;
return *this;
}
- operator const VkObjectTablePipelineEntryNVX&() const
+ DeviceGroupPresentInfoKHX& setMode( DeviceGroupPresentModeFlagBitsKHX mode_ )
{
- return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
+ mode = mode_;
+ return *this;
}
- bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
+ operator const VkDeviceGroupPresentInfoKHX&() const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( pipeline == rhs.pipeline );
+ return *reinterpret_cast<const VkDeviceGroupPresentInfoKHX*>(this);
}
- bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
+ bool operator==( DeviceGroupPresentInfoKHX const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( swapchainCount == rhs.swapchainCount )
+ && ( pDeviceMasks == rhs.pDeviceMasks )
+ && ( mode == rhs.mode );
+ }
+
+ bool operator!=( DeviceGroupPresentInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Pipeline pipeline;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ uint32_t swapchainCount;
+ const uint32_t* pDeviceMasks;
+ DeviceGroupPresentModeFlagBitsKHX mode;
};
- static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupPresentInfoKHX ) == sizeof( VkDeviceGroupPresentInfoKHX ), "struct and wrapper have different size!" );
- struct ObjectTableDescriptorSetEntryNVX
+ struct DeviceGroupSwapchainCreateInfoKHX
{
- ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() )
- : type( type_ )
- , flags( flags_ )
- , pipelineLayout( pipelineLayout_ )
- , descriptorSet( descriptorSet_ )
+ DeviceGroupSwapchainCreateInfoKHX( DeviceGroupPresentModeFlagsKHX modes_ = DeviceGroupPresentModeFlagsKHX() )
+ : sType( StructureType::eDeviceGroupSwapchainCreateInfoKHX )
+ , pNext( nullptr )
+ , modes( modes_ )
{
}
- ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
+ DeviceGroupSwapchainCreateInfoKHX( VkDeviceGroupSwapchainCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) );
+ memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) );
}
- ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
+ DeviceGroupSwapchainCreateInfoKHX& operator=( VkDeviceGroupSwapchainCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) );
+ memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) );
return *this;
}
- ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ DeviceGroupSwapchainCreateInfoKHX& setPNext( const void* pNext_ )
{
- type = type_;
+ pNext = pNext_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ DeviceGroupSwapchainCreateInfoKHX& setModes( DeviceGroupPresentModeFlagsKHX modes_ )
{
- flags = flags_;
+ modes = modes_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
+ operator const VkDeviceGroupSwapchainCreateInfoKHX&() const
{
- pipelineLayout = pipelineLayout_;
- return *this;
+ return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHX*>(this);
}
- ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ )
+ bool operator==( DeviceGroupSwapchainCreateInfoKHX const& rhs ) const
{
- descriptorSet = descriptorSet_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( modes == rhs.modes );
}
- operator const VkObjectTableDescriptorSetEntryNVX&() const
+ bool operator!=( DeviceGroupSwapchainCreateInfoKHX const& rhs ) const
{
- return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
+ return !operator==( rhs );
}
- bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ DeviceGroupPresentModeFlagsKHX modes;
+ };
+ static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHX ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
+
+ enum class SwapchainCreateFlagBitsKHR
+ {
+ eBindSfrKHX = VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX
+ };
+
+ using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
+
+ VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ {
+ return SwapchainCreateFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
+ {
+ return ~( SwapchainCreateFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eBindSfrKHX)
+ };
+ };
+
+ 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_ )
+ , surface( surface_ )
+ , minImageCount( minImageCount_ )
+ , imageFormat( imageFormat_ )
+ , imageColorSpace( imageColorSpace_ )
+ , imageExtent( imageExtent_ )
+ , imageArrayLayers( imageArrayLayers_ )
+ , imageUsage( imageUsage_ )
+ , imageSharingMode( imageSharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , preTransform( preTransform_ )
+ , compositeAlpha( compositeAlpha_ )
+ , presentMode( presentMode_ )
+ , clipped( clipped_ )
+ , oldSwapchain( oldSwapchain_ )
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( pipelineLayout == rhs.pipelineLayout )
- && ( descriptorSet == rhs.descriptorSet );
}
- bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+ SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- PipelineLayout pipelineLayout;
- DescriptorSet descriptorSet;
- };
- static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
+ SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
+ return *this;
+ }
- struct ObjectTableVertexBufferEntryNVX
- {
- ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() )
- : type( type_ )
- , flags( flags_ )
- , buffer( buffer_ )
+ SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
{
+ pNext = pNext_;
+ return *this;
}
- ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
+ SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
{
- memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) );
+ flags = flags_;
+ return *this;
}
- ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
+ SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
+ {
+ surface = surface_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
{
- memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) );
+ minImageCount = minImageCount_;
return *this;
}
- ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
{
- type = type_;
+ imageFormat = imageFormat_;
return *this;
}
- ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
{
- flags = flags_;
+ imageColorSpace = imageColorSpace_;
return *this;
}
- ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ )
+ SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
{
- buffer = buffer_;
+ imageExtent = imageExtent_;
return *this;
}
- operator const VkObjectTableVertexBufferEntryNVX&() const
+ SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
{
- return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
+ imageArrayLayers = imageArrayLayers_;
+ return *this;
}
- bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( buffer == rhs.buffer );
+ imageUsage = imageUsage_;
+ return *this;
}
- bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
{
- return !operator==( rhs );
+ imageSharingMode = imageSharingMode_;
+ return *this;
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Buffer buffer;
- };
- static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
-
- struct ObjectTableIndexBufferEntryNVX
- {
- ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 )
- : type( type_ )
- , flags( flags_ )
- , buffer( buffer_ )
- , indexType( indexType_ )
+ SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
{
+ queueFamilyIndexCount = queueFamilyIndexCount_;
+ return *this;
}
- ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
+ SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
{
- memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) );
+ pQueueFamilyIndices = pQueueFamilyIndices_;
+ return *this;
}
- ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
+ SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
{
- memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) );
+ preTransform = preTransform_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
{
- type = type_;
+ compositeAlpha = compositeAlpha_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
{
- flags = flags_;
+ presentMode = presentMode_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ )
+ SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
{
- buffer = buffer_;
+ clipped = clipped_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ )
+ SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
{
- indexType = indexType_;
+ oldSwapchain = oldSwapchain_;
return *this;
}
- operator const VkObjectTableIndexBufferEntryNVX&() const
+ operator const VkSwapchainCreateInfoKHR&() const
{
- return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
+ return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
}
- bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
+ bool operator==( SwapchainCreateInfoKHR const& rhs ) const
{
- return ( type == rhs.type )
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( buffer == rhs.buffer )
- && ( indexType == rhs.indexType );
+ && ( surface == rhs.surface )
+ && ( minImageCount == rhs.minImageCount )
+ && ( imageFormat == rhs.imageFormat )
+ && ( imageColorSpace == rhs.imageColorSpace )
+ && ( imageExtent == rhs.imageExtent )
+ && ( imageArrayLayers == rhs.imageArrayLayers )
+ && ( imageUsage == rhs.imageUsage )
+ && ( imageSharingMode == rhs.imageSharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
+ && ( preTransform == rhs.preTransform )
+ && ( compositeAlpha == rhs.compositeAlpha )
+ && ( presentMode == rhs.presentMode )
+ && ( clipped == rhs.clipped )
+ && ( oldSwapchain == rhs.oldSwapchain );
}
- bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
+ bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Buffer buffer;
- IndexType indexType;
+ private:
+ StructureType sType;
+
+ public:
+ const void* pNext;
+ SwapchainCreateFlagsKHR flags;
+ SurfaceKHR surface;
+ uint32_t minImageCount;
+ Format imageFormat;
+ ColorSpaceKHR imageColorSpace;
+ Extent2D imageExtent;
+ uint32_t imageArrayLayers;
+ ImageUsageFlags imageUsage;
+ SharingMode imageSharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ SurfaceTransformFlagBitsKHR preTransform;
+ CompositeAlphaFlagBitsKHR compositeAlpha;
+ PresentModeKHR presentMode;
+ Bool32 clipped;
+ SwapchainKHR oldSwapchain;
};
- static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
- struct ObjectTablePushConstantEntryNVX
+ enum class ViewportCoordinateSwizzleNV
{
- ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() )
- : type( type_ )
- , flags( flags_ )
- , pipelineLayout( pipelineLayout_ )
- , stageFlags( stageFlags_ )
+ ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
+ eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
+ ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
+ eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
+ ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
+ eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
+ ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
+ eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+ };
+
+ struct ViewportSwizzleNV
+ {
+ ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX )
+ : x( x_ )
+ , y( y_ )
+ , z( z_ )
+ , w( w_ )
{
}
- ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
+ ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) );
+ memcpy( this, &rhs, sizeof(ViewportSwizzleNV) );
}
- ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
+ ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) );
+ memcpy( this, &rhs, sizeof(ViewportSwizzleNV) );
return *this;
}
- ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ )
{
- type = type_;
+ x = x_;
return *this;
}
- ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ )
{
- flags = flags_;
+ y = y_;
return *this;
}
- ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
+ ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ )
{
- pipelineLayout = pipelineLayout_;
+ z = z_;
return *this;
}
- ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ )
+ ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ )
{
- stageFlags = stageFlags_;
+ w = w_;
return *this;
}
- operator const VkObjectTablePushConstantEntryNVX&() const
+ operator const VkViewportSwizzleNV&() const
{
- return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
+ return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
}
- bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
+ bool operator==( ViewportSwizzleNV const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( pipelineLayout == rhs.pipelineLayout )
- && ( stageFlags == rhs.stageFlags );
+ return ( x == rhs.x )
+ && ( y == rhs.y )
+ && ( z == rhs.z )
+ && ( w == rhs.w );
}
- bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
+ bool operator!=( ViewportSwizzleNV const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- PipelineLayout pipelineLayout;
- ShaderStageFlags stageFlags;
+ ViewportCoordinateSwizzleNV x;
+ ViewportCoordinateSwizzleNV y;
+ ViewportCoordinateSwizzleNV z;
+ ViewportCoordinateSwizzleNV w;
};
- static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
- enum class SurfaceCounterFlagBitsEXT
+ struct PipelineViewportSwizzleStateCreateInfoNV
{
- eVblankExt = VK_SURFACE_COUNTER_VBLANK_EXT
- };
+ PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
+ : sType( StructureType::ePipelineViewportSwizzleStateCreateInfoNV )
+ , pNext( nullptr )
+ , flags( flags_ )
+ , viewportCount( viewportCount_ )
+ , pViewportSwizzles( pViewportSwizzles_ )
+ {
+ }
- using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
+ PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) );
+ }
- VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
- {
- return SurfaceCounterFlagsEXT( bit0 ) | bit1;
- }
+ PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) );
+ return *this;
+ }
- VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
- {
- return ~( SurfaceCounterFlagsEXT( bits ) );
- }
+ PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
- {
- enum
+ PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
{
- allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblankExt)
- };
- };
+ flags = flags_;
+ return *this;
+ }
- struct SurfaceCapabilities2EXT
- {
- operator const VkSurfaceCapabilities2EXT&() const
+ PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
{
- return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
+ viewportCount = viewportCount_;
+ return *this;
}
- bool operator==( SurfaceCapabilities2EXT const& rhs ) const
+ PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
+ {
+ pViewportSwizzles = pViewportSwizzles_;
+ return *this;
+ }
+
+ operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const
+ {
+ return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+ }
+
+ bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( minImageCount == rhs.minImageCount )
- && ( maxImageCount == rhs.maxImageCount )
- && ( currentExtent == rhs.currentExtent )
- && ( minImageExtent == rhs.minImageExtent )
- && ( maxImageExtent == rhs.maxImageExtent )
- && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
- && ( supportedTransforms == rhs.supportedTransforms )
- && ( currentTransform == rhs.currentTransform )
- && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
- && ( supportedUsageFlags == rhs.supportedUsageFlags )
- && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+ && ( flags == rhs.flags )
+ && ( viewportCount == rhs.viewportCount )
+ && ( pViewportSwizzles == rhs.pViewportSwizzles );
}
- bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
+ bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
public:
- void* pNext;
- uint32_t minImageCount;
- uint32_t maxImageCount;
- Extent2D currentExtent;
- Extent2D minImageExtent;
- Extent2D maxImageExtent;
- uint32_t maxImageArrayLayers;
- SurfaceTransformFlagsKHR supportedTransforms;
- SurfaceTransformFlagBitsKHR currentTransform;
- CompositeAlphaFlagsKHR supportedCompositeAlpha;
- ImageUsageFlags supportedUsageFlags;
- SurfaceCounterFlagsEXT supportedSurfaceCounters;
+ const void* pNext;
+ PipelineViewportSwizzleStateCreateFlagsNV flags;
+ uint32_t viewportCount;
+ const ViewportSwizzleNV* pViewportSwizzles;
};
- static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
- struct SwapchainCounterCreateInfoEXT
+ enum class DiscardRectangleModeEXT
{
- SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
- : sType( StructureType::eSwapchainCounterCreateInfoEXT )
+ eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
+ eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
+ };
+
+ struct PipelineDiscardRectangleStateCreateInfoEXT
+ {
+ PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const Rect2D* pDiscardRectangles_ = nullptr )
+ : sType( StructureType::ePipelineDiscardRectangleStateCreateInfoEXT )
, pNext( nullptr )
- , surfaceCounters( surfaceCounters_ )
+ , flags( flags_ )
+ , discardRectangleMode( discardRectangleMode_ )
+ , discardRectangleCount( discardRectangleCount_ )
+ , pDiscardRectangles( pDiscardRectangles_ )
{
}
- SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
+ PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) );
}
- SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
+ PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) );
return *this;
}
- SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
+ PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
+ PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
{
- surfaceCounters = surfaceCounters_;
+ flags = flags_;
return *this;
}
- operator const VkSwapchainCounterCreateInfoEXT&() const
+ PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
{
- return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
+ discardRectangleMode = discardRectangleMode_;
+ return *this;
}
- bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
+ PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ )
+ {
+ discardRectangleCount = discardRectangleCount_;
+ return *this;
+ }
+
+ PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
+ {
+ pDiscardRectangles = pDiscardRectangles_;
+ return *this;
+ }
+
+ operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const
+ {
+ return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
+ }
+
+ bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( surfaceCounters == rhs.surfaceCounters );
+ && ( flags == rhs.flags )
+ && ( discardRectangleMode == rhs.discardRectangleMode )
+ && ( discardRectangleCount == rhs.discardRectangleCount )
+ && ( pDiscardRectangles == rhs.pDiscardRectangles );
}
- bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
+ bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- SurfaceCounterFlagsEXT surfaceCounters;
+ PipelineDiscardRectangleStateCreateFlagsEXT flags;
+ DiscardRectangleModeEXT discardRectangleMode;
+ uint32_t discardRectangleCount;
+ const Rect2D* pDiscardRectangles;
};
- static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
- enum class DisplayPowerStateEXT
+ enum class SubpassDescriptionFlagBits
{
- eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
- eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
- eOn = VK_DISPLAY_POWER_STATE_ON_EXT
+ ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
+ ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
};
- struct DisplayPowerInfoEXT
+ using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
+
+ VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
{
- DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
- : sType( StructureType::eDisplayPowerInfoEXT )
- , pNext( nullptr )
- , powerState( powerState_ )
+ return SubpassDescriptionFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
+ {
+ return ~( SubpassDescriptionFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SubpassDescriptionFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
+ };
+ };
+
+ struct SubpassDescription
+ {
+ SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, uint32_t inputAttachmentCount_ = 0, const AttachmentReference* pInputAttachments_ = nullptr, uint32_t colorAttachmentCount_ = 0, const AttachmentReference* pColorAttachments_ = nullptr, const AttachmentReference* pResolveAttachments_ = nullptr, const AttachmentReference* pDepthStencilAttachment_ = nullptr, uint32_t preserveAttachmentCount_ = 0, const uint32_t* pPreserveAttachments_ = nullptr )
+ : flags( flags_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , inputAttachmentCount( inputAttachmentCount_ )
+ , pInputAttachments( pInputAttachments_ )
+ , colorAttachmentCount( colorAttachmentCount_ )
+ , pColorAttachments( pColorAttachments_ )
+ , pResolveAttachments( pResolveAttachments_ )
+ , pDepthStencilAttachment( pDepthStencilAttachment_ )
+ , preserveAttachmentCount( preserveAttachmentCount_ )
+ , pPreserveAttachments( pPreserveAttachments_ )
{
}
- DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
+ SubpassDescription( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) );
+ memcpy( this, &rhs, sizeof(SubpassDescription) );
}
- DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
+ SubpassDescription& operator=( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) );
+ memcpy( this, &rhs, sizeof(SubpassDescription) );
return *this;
}
- DisplayPowerInfoEXT& setPNext( const void* pNext_ )
+ SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
{
- pNext = pNext_;
+ flags = flags_;
return *this;
}
- DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ )
+ SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- powerState = powerState_;
+ pipelineBindPoint = pipelineBindPoint_;
return *this;
}
- operator const VkDisplayPowerInfoEXT&() const
+ SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
{
- return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
+ inputAttachmentCount = inputAttachmentCount_;
+ return *this;
}
- bool operator==( DisplayPowerInfoEXT const& rhs ) const
+ SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( powerState == rhs.powerState );
+ pInputAttachments = pInputAttachments_;
+ return *this;
}
- bool operator!=( DisplayPowerInfoEXT const& rhs ) const
+ SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
{
- return !operator==( rhs );
+ colorAttachmentCount = colorAttachmentCount_;
+ return *this;
}
- private:
- StructureType sType;
-
- public:
- const void* pNext;
- DisplayPowerStateEXT powerState;
- };
- static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
-
- enum class DeviceEventTypeEXT
- {
- eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
- };
-
- struct DeviceEventInfoEXT
- {
- DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
- : sType( StructureType::eDeviceEventInfoEXT )
- , pNext( nullptr )
- , deviceEvent( deviceEvent_ )
+ SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
{
+ pColorAttachments = pColorAttachments_;
+ return *this;
}
- DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
+ SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
{
- memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) );
+ pResolveAttachments = pResolveAttachments_;
+ return *this;
}
- DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
+ SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
{
- memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) );
+ pDepthStencilAttachment = pDepthStencilAttachment_;
return *this;
}
- DeviceEventInfoEXT& setPNext( const void* pNext_ )
+ SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
{
- pNext = pNext_;
+ preserveAttachmentCount = preserveAttachmentCount_;
return *this;
}
- DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
+ SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
{
- deviceEvent = deviceEvent_;
+ pPreserveAttachments = pPreserveAttachments_;
return *this;
}
- operator const VkDeviceEventInfoEXT&() const
+ operator const VkSubpassDescription&() const
{
- return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
+ return *reinterpret_cast<const VkSubpassDescription*>(this);
}
- bool operator==( DeviceEventInfoEXT const& rhs ) const
+ bool operator==( SubpassDescription const& rhs ) const
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( deviceEvent == rhs.deviceEvent );
+ return ( flags == rhs.flags )
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( inputAttachmentCount == rhs.inputAttachmentCount )
+ && ( pInputAttachments == rhs.pInputAttachments )
+ && ( colorAttachmentCount == rhs.colorAttachmentCount )
+ && ( pColorAttachments == rhs.pColorAttachments )
+ && ( pResolveAttachments == rhs.pResolveAttachments )
+ && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
+ && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
+ && ( pPreserveAttachments == rhs.pPreserveAttachments );
}
- bool operator!=( DeviceEventInfoEXT const& rhs ) const
+ bool operator!=( SubpassDescription const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType;
-
- public:
- const void* pNext;
- DeviceEventTypeEXT deviceEvent;
- };
- static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
-
- enum class DisplayEventTypeEXT
- {
- eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
+ SubpassDescriptionFlags flags;
+ PipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+ const AttachmentReference* pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const AttachmentReference* pColorAttachments;
+ const AttachmentReference* pResolveAttachments;
+ const AttachmentReference* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t* pPreserveAttachments;
};
+ static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
- struct DisplayEventInfoEXT
+ struct RenderPassCreateInfo
{
- DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
- : sType( StructureType::eDisplayEventInfoEXT )
+ 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 )
- , displayEvent( displayEvent_ )
+ , flags( flags_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , subpassCount( subpassCount_ )
+ , pSubpasses( pSubpasses_ )
+ , dependencyCount( dependencyCount_ )
+ , pDependencies( pDependencies_ )
{
}
- DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
+ RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) );
+ memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
}
- DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
+ RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) );
+ memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
return *this;
}
- DisplayEventInfoEXT& setPNext( const void* pNext_ )
+ RenderPassCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
+ RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
{
- displayEvent = displayEvent_;
+ flags = flags_;
return *this;
}
- operator const VkDisplayEventInfoEXT&() const
+ RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
{
- return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
+ attachmentCount = attachmentCount_;
+ return *this;
}
- bool operator==( DisplayEventInfoEXT const& rhs ) const
+ RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
+ {
+ pAttachments = pAttachments_;
+ return *this;
+ }
+
+ RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
+ {
+ subpassCount = subpassCount_;
+ return *this;
+ }
+
+ RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
+ {
+ pSubpasses = pSubpasses_;
+ return *this;
+ }
+
+ RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
+ {
+ dependencyCount = dependencyCount_;
+ return *this;
+ }
+
+ RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
+ {
+ pDependencies = pDependencies_;
+ return *this;
+ }
+
+ operator const VkRenderPassCreateInfo&() const
+ {
+ return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
+ }
+
+ bool operator==( RenderPassCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( displayEvent == rhs.displayEvent );
+ && ( flags == rhs.flags )
+ && ( attachmentCount == rhs.attachmentCount )
+ && ( pAttachments == rhs.pAttachments )
+ && ( subpassCount == rhs.subpassCount )
+ && ( pSubpasses == rhs.pSubpasses )
+ && ( dependencyCount == rhs.dependencyCount )
+ && ( pDependencies == rhs.pDependencies );
}
- bool operator!=( DisplayEventInfoEXT const& rhs ) const
+ bool operator!=( RenderPassCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- DisplayEventTypeEXT displayEvent;
+ RenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const AttachmentDescription* pAttachments;
+ uint32_t subpassCount;
+ const SubpassDescription* pSubpasses;
+ uint32_t dependencyCount;
+ const SubpassDependency* pDependencies;
};
- static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const;
- void dispatch( uint32_t x, uint32_t y, uint32_t z ) const;
+ void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const;
void dispatchIndirect( Buffer buffer, DeviceSize offset ) const;
void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ void setDeviceMaskKHX( uint32_t deviceMask ) const;
+
+ void dispatchBaseKHX( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const;
+
+ void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData ) const;
+
+ void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
{
return m_commandBuffer;
vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
}
- VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t x, uint32_t y, uint32_t z ) const
+ VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
{
- vkCmdDispatch( m_commandBuffer, x, y, z );
+ vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
}
VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset ) const
vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( &reserveSpaceInfo ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites ) const
+ {
+ vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites ) const
+ {
+ vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHX( uint32_t deviceMask ) const
+ {
+ vkCmdSetDeviceMaskKHX( m_commandBuffer, deviceMask );
+ }
+
+ VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHX( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+ {
+ vkCmdDispatchBaseKHX( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+ }
+
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData ) const
+ {
+ vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
+ }
+
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings ) const
+ {
+ vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings ) const
+ {
+ vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles ) const
+ {
+ vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const
+ {
+ vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
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 )
using UniqueDescriptorSet = UniqueHandle<DescriptorSet, DescriptorSetDeleter>;
class DescriptorSetLayoutDeleter;
using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, DescriptorSetLayoutDeleter>;
+ class DescriptorUpdateTemplateKHRDeleter;
+ using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplateKHR, DescriptorUpdateTemplateKHRDeleter>;
class DeviceMemoryDeleter;
using UniqueDeviceMemory = UniqueHandle<DeviceMemory, DeviceMemoryDeleter>;
class EventDeleter;
void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags ) const;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ Result getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<HANDLE>::type getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ Result getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, MemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<MemoryWin32HandlePropertiesKHX>::type getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ Result getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<int>::type getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, MemoryFdPropertiesKHX* pMemoryFdProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<MemoryFdPropertiesKHX>::type getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ Result getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ Result importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<void>::type importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX & importSemaphoreWin32HandleInfo ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
+
+ Result getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<int>::type getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<void>::type importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX & importSemaphoreFdInfo ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo ) const;
ResultValue<uint64_t> getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ void getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ PeerMemoryFeatureFlagsKHX getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result bindBufferMemory2KHX( uint32_t bindInfoCount, const BindBufferMemoryInfoKHX* pBindInfos ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<void>::type bindBufferMemory2KHX( ArrayProxy<const BindBufferMemoryInfoKHX> bindInfos ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result bindImageMemory2KHX( uint32_t bindInfoCount, const BindImageMemoryInfoKHX* pBindInfos ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<void>::type bindImageMemory2KHX( ArrayProxy<const BindImageMemoryInfoKHX> bindInfos ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result getGroupPresentCapabilitiesKHX( DeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<DeviceGroupPresentCapabilitiesKHX>::type getGroupPresentCapabilitiesKHX() const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result getGroupSurfacePresentModesKHX( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHX* pModes ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<DeviceGroupPresentModeFlagsKHX>::type getGroupSurfacePresentModesKHX( SurfaceKHR surface ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result acquireNextImage2KHX( const AcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValue<uint32_t> acquireNextImage2KHX( const AcquireNextImageInfoKHX & acquireInfo ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<DescriptorUpdateTemplateKHR>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ UniqueDescriptorUpdateTemplateKHR createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const AllocationCallbacks* pAllocator ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData ) const;
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
{
return m_device;
Optional<const AllocationCallbacks> m_allocator;
};
+ class DescriptorUpdateTemplateKHRDeleter
+ {
+ public:
+ DescriptorUpdateTemplateKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
+ : m_device( device )
+ , m_allocator( allocator )
+ {}
+
+ void operator()( DescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
+ {
+ m_device.destroyDescriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR, m_allocator );
+ }
+
+ private:
+ Device m_device;
+ Optional<const AllocationCallbacks> m_allocator;
+ };
+
class DeviceMemoryDeleter
{
public:
vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlagsKHR>( flags ) );
}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const
+ {
+ return static_cast<Result>( vkGetMemoryWin32HandleKHX( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), pHandle ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const
+ {
+ HANDLE handle;
+ Result result = static_cast<Result>( vkGetMemoryWin32HandleKHX( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), &handle ) );
+ return createResultValue( result, handle, "vk::Device::getMemoryWin32HandleKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, MemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties ) const
+ {
+ return static_cast<Result>( vkGetMemoryWin32HandlePropertiesKHX( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHX*>( pMemoryWin32HandleProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHX>::type Device::getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle ) const
+ {
+ MemoryWin32HandlePropertiesKHX memoryWin32HandleProperties;
+ Result result = static_cast<Result>( vkGetMemoryWin32HandlePropertiesKHX( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHX*>( &memoryWin32HandleProperties ) ) );
+ return createResultValue( result, memoryWin32HandleProperties, "vk::Device::getMemoryWin32HandlePropertiesKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ VULKAN_HPP_INLINE Result Device::getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd ) const
+ {
+ return static_cast<Result>( vkGetMemoryFdKHX( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), pFd ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<int>::type Device::getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const
+ {
+ int fd;
+ Result result = static_cast<Result>( vkGetMemoryFdKHX( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), &fd ) );
+ return createResultValue( result, fd, "vk::Device::getMemoryFdKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, MemoryFdPropertiesKHX* pMemoryFdProperties ) const
+ {
+ return static_cast<Result>( vkGetMemoryFdPropertiesKHX( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHX*>( pMemoryFdProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHX>::type Device::getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd ) const
+ {
+ MemoryFdPropertiesKHX memoryFdProperties;
+ Result result = static_cast<Result>( vkGetMemoryFdPropertiesKHX( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHX>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHX*>( &memoryFdProperties ) ) );
+ return createResultValue( result, memoryFdProperties, "vk::Device::getMemoryFdPropertiesKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const
+ {
+ return static_cast<Result>( vkGetSemaphoreWin32HandleKHX( m_device, static_cast<VkSemaphore>( semaphore ), static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHX>( handleType ), pHandle ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const
+ {
+ HANDLE handle;
+ Result result = static_cast<Result>( vkGetSemaphoreWin32HandleKHX( m_device, static_cast<VkSemaphore>( semaphore ), static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHX>( handleType ), &handle ) );
+ return createResultValue( result, handle, "vk::Device::getSemaphoreWin32HandleKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+ VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo ) const
+ {
+ return static_cast<Result>( vkImportSemaphoreWin32HandleKHX( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHX*>( pImportSemaphoreWin32HandleInfo ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX & importSemaphoreWin32HandleInfo ) const
+ {
+ Result result = static_cast<Result>( vkImportSemaphoreWin32HandleKHX( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHX*>( &importSemaphoreWin32HandleInfo ) ) );
+ return createResultValue( result, "vk::Device::importSemaphoreWin32HandleKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHX*/
+
+ VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd ) const
+ {
+ return static_cast<Result>( vkGetSemaphoreFdKHX( m_device, static_cast<VkSemaphore>( semaphore ), static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHX>( handleType ), pFd ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<int>::type Device::getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const
+ {
+ int fd;
+ Result result = static_cast<Result>( vkGetSemaphoreFdKHX( m_device, static_cast<VkSemaphore>( semaphore ), static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHX>( handleType ), &fd ) );
+ return createResultValue( result, fd, "vk::Device::getSemaphoreFdKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo ) const
+ {
+ return static_cast<Result>( vkImportSemaphoreFdKHX( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHX*>( pImportSemaphoreFdInfo ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX & importSemaphoreFdInfo ) const
+ {
+ Result result = static_cast<Result>( vkImportSemaphoreFdKHX( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHX*>( &importSemaphoreFdInfo ) ) );
+ return createResultValue( result, "vk::Device::importSemaphoreFdKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const
{
return static_cast<Result>( vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const
+ VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const
+ {
+ return static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, const AllocationCallbacks & allocator ) const
+ {
+ Fence fence;
+ Result result = static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( &allocator ), reinterpret_cast<VkFence*>( &fence ) ) );
+ return createResultValue( result, fence, "vk::Device::registerDisplayEventEXT" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const
+ {
+ return static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValue<uint64_t> Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const
+ {
+ uint64_t counterValue;
+ Result result = static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
+ return createResultValue( result, counterValue, "vk::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorDeviceLost, Result::eErrorOutOfDateKHR } );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures ) const
+ {
+ vkGetDeviceGroupPeerMemoryFeaturesKHX( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlagsKHX*>( pPeerMemoryFeatures ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX Device::getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const
+ {
+ PeerMemoryFeatureFlagsKHX peerMemoryFeatures;
+ vkGetDeviceGroupPeerMemoryFeaturesKHX( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlagsKHX*>( &peerMemoryFeatures ) );
+ return peerMemoryFeatures;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHX( uint32_t bindInfoCount, const BindBufferMemoryInfoKHX* pBindInfos ) const
+ {
+ return static_cast<Result>( vkBindBufferMemory2KHX( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfoKHX*>( pBindInfos ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHX( ArrayProxy<const BindBufferMemoryInfoKHX> bindInfos ) const
+ {
+ Result result = static_cast<Result>( vkBindBufferMemory2KHX( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfoKHX*>( bindInfos.data() ) ) );
+ return createResultValue( result, "vk::Device::bindBufferMemory2KHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::bindImageMemory2KHX( uint32_t bindInfoCount, const BindImageMemoryInfoKHX* pBindInfos ) const
+ {
+ return static_cast<Result>( vkBindImageMemory2KHX( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfoKHX*>( pBindInfos ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHX( ArrayProxy<const BindImageMemoryInfoKHX> bindInfos ) const
+ {
+ Result result = static_cast<Result>( vkBindImageMemory2KHX( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfoKHX*>( bindInfos.data() ) ) );
+ return createResultValue( result, "vk::Device::bindImageMemory2KHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHX( DeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities ) const
+ {
+ return static_cast<Result>( vkGetDeviceGroupPresentCapabilitiesKHX( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX*>( pDeviceGroupPresentCapabilities ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHX>::type Device::getGroupPresentCapabilitiesKHX() const
+ {
+ DeviceGroupPresentCapabilitiesKHX deviceGroupPresentCapabilities;
+ Result result = static_cast<Result>( vkGetDeviceGroupPresentCapabilitiesKHX( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX*>( &deviceGroupPresentCapabilities ) ) );
+ return createResultValue( result, deviceGroupPresentCapabilities, "vk::Device::getGroupPresentCapabilitiesKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHX( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHX* pModes ) const
+ {
+ return static_cast<Result>( vkGetDeviceGroupSurfacePresentModesKHX( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHX*>( pModes ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHX>::type Device::getGroupSurfacePresentModesKHX( SurfaceKHR surface ) const
+ {
+ DeviceGroupPresentModeFlagsKHX modes;
+ Result result = static_cast<Result>( vkGetDeviceGroupSurfacePresentModesKHX( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHX*>( &modes ) ) );
+ return createResultValue( result, modes, "vk::Device::getGroupSurfacePresentModesKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::acquireNextImage2KHX( const AcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex ) const
+ {
+ return static_cast<Result>( vkAcquireNextImage2KHX( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHX*>( pAcquireInfo ), pImageIndex ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHX( const AcquireNextImageInfoKHX & acquireInfo ) const
+ {
+ uint32_t imageIndex;
+ Result result = static_cast<Result>( vkAcquireNextImage2KHX( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHX*>( &acquireInfo ), &imageIndex ) );
+ return createResultValue( result, imageIndex, "vk::Device::acquireNextImage2KHX", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate ) const
{
- return static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
+ return static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( pDescriptorUpdateTemplate ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, const AllocationCallbacks & allocator ) const
+ VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplateKHR>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
{
- Fence fence;
- Result result = static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( &allocator ), reinterpret_cast<VkFence*>( &fence ) ) );
- return createResultValue( result, fence, "vk::Device::registerDisplayEventEXT" );
+ DescriptorUpdateTemplateKHR descriptorUpdateTemplate;
+ Result result = static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( &descriptorUpdateTemplate ) ) );
+ return createResultValue( result, descriptorUpdateTemplate, "vk::Device::createDescriptorUpdateTemplateKHR" );
+ }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ VULKAN_HPP_INLINE UniqueDescriptorUpdateTemplateKHR Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
+ {
+ DescriptorUpdateTemplateKHRDeleter deleter( *this, allocator );
+ return UniqueDescriptorUpdateTemplateKHR( createDescriptorUpdateTemplateKHR( createInfo, allocator ), deleter );
}
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const AllocationCallbacks* pAllocator ) const
{
- return static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
+ vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValue<uint64_t> Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator ) const
{
- uint64_t counterValue;
- Result result = static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
- return createResultValue( result, counterValue, "vk::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorDeviceLost, Result::eErrorOutOfDateKHR } );
+ vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData ) const
+ {
+ vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), pData );
+ }
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class DeviceDeleter;
using UniqueDevice = UniqueHandle<Device, DeviceDeleter>;
std::vector<SparseImageFormatProperties2KHR,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ void getProperties2KHX( PhysicalDeviceProperties2KHX* pProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ PhysicalDeviceProperties2KHX getProperties2KHX() const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ Result getImageFormatProperties2KHX( const PhysicalDeviceImageFormatInfo2KHX* pImageFormatInfo, ImageFormatProperties2KHX* pImageFormatProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<ImageFormatProperties2KHX>::type getImageFormatProperties2KHX( const PhysicalDeviceImageFormatInfo2KHX & imageFormatInfo ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ void getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, ExternalBufferPropertiesKHX* pExternalBufferProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ExternalBufferPropertiesKHX getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX & externalBufferInfo ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ void getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ExternalSemaphorePropertiesKHX getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX & externalSemaphoreInfo ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
Result releaseDisplayEXT( DisplayKHR display ) const;
#else
ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ Result getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator = std::allocator<Rect2D>>
+ typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHX( SurfaceKHR surface ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
{
return m_physicalDevice;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_MIR_KHR*/
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const
+ {
+ return static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const
+ {
+ Bool32 supported;
+ Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) );
+ return createResultValue( result, supported, "vk::PhysicalDevice::getSurfaceSupportKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
+ {
+ return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const
+ {
+ SurfaceCapabilitiesKHR surfaceCapabilities;
+ Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
+ return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilitiesKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const
+ {
+ return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface ) const
+ {
+ std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
+ uint32_t surfaceFormatCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+ {
+ surfaceFormats.resize( surfaceFormatCount );
+ result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ assert( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
+ return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormatsKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const
+ {
+ return static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface ) const
+ {
+ std::vector<PresentModeKHR,Allocator> presentModes;
+ uint32_t presentModeCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && presentModeCount )
+ {
+ presentModes.resize( presentModeCount );
+ result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ assert( presentModeCount <= presentModes.size() );
+ presentModes.resize( presentModeCount );
+ return createResultValue( result, presentModes, "vk::PhysicalDevice::getSurfacePresentModesKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const
+ {
+ return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const
+ {
+ return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const
+ {
+ return vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
+ }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
+ {
+ return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const
+ {
+ return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
+ {
+ return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const
+ {
+ return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+ VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const
+ {
+ return static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const
+ {
+ ExternalImageFormatPropertiesNV externalImageFormatProperties;
+ Result result = static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
+ return createResultValue( result, externalImageFormatProperties, "vk::PhysicalDevice::getExternalImageFormatPropertiesNV" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits ) const
+ {
+ vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features ) const
+ {
+ DeviceGeneratedCommandsLimitsNVX limits;
+ vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
+ return limits;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2KHR* pFeatures ) const
+ {
+ vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( pFeatures ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE PhysicalDeviceFeatures2KHR PhysicalDevice::getFeatures2KHR() const
+ {
+ PhysicalDeviceFeatures2KHR features;
+ vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( &features ) );
+ return features;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2KHR* pProperties ) const
+ {
+ vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( pProperties ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE PhysicalDeviceProperties2KHR PhysicalDevice::getProperties2KHR() const
+ {
+ PhysicalDeviceProperties2KHR properties;
+ vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( &properties ) );
+ return properties;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2KHR* pFormatProperties ) const
+ {
+ vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( pFormatProperties ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE FormatProperties2KHR PhysicalDevice::getFormatProperties2KHR( Format format ) const
+ {
+ FormatProperties2KHR formatProperties;
+ vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( &formatProperties ) );
+ return formatProperties;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, ImageFormatProperties2KHR* pImageFormatProperties ) const
+ {
+ return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( pImageFormatProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2KHR>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const
+ {
+ ImageFormatProperties2KHR imageFormatProperties;
+ Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( &imageFormatProperties ) ) );
+ return createResultValue( result, imageFormatProperties, "vk::PhysicalDevice::getImageFormatProperties2KHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const
+ {
+ vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( pQueueFamilyProperties ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator>
+ VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2KHR,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR() const
+ {
+ std::vector<QueueFamilyProperties2KHR,Allocator> queueFamilyProperties;
+ uint32_t queueFamilyPropertyCount;
+ vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ queueFamilyProperties.resize( queueFamilyPropertyCount );
+ vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( queueFamilyProperties.data() ) );
+ return queueFamilyProperties;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const
{
- return static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) );
+ vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( pMemoryProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const
+ VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2KHR PhysicalDevice::getMemoryProperties2KHR() const
{
- Bool32 supported;
- Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) );
- return createResultValue( result, supported, "vk::PhysicalDevice::getSurfaceSupportKHR" );
+ PhysicalDeviceMemoryProperties2KHR memoryProperties;
+ vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( &memoryProperties ) );
+ return memoryProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const
{
- return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
+ vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const
+ template <typename Allocator>
+ VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2KHR,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const
{
- SurfaceCapabilitiesKHR surfaceCapabilities;
- Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
- return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilitiesKHR" );
+ std::vector<SparseImageFormatProperties2KHR,Allocator> properties;
+ uint32_t propertyCount;
+ vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, nullptr );
+ properties.resize( propertyCount );
+ vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( properties.data() ) );
+ return properties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHX( PhysicalDeviceProperties2KHX* pProperties ) const
{
- return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
+ vkGetPhysicalDeviceProperties2KHX( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHX*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template <typename Allocator>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface ) const
+ VULKAN_HPP_INLINE PhysicalDeviceProperties2KHX PhysicalDevice::getProperties2KHX() const
{
- std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
- uint32_t surfaceFormatCount;
- Result result;
- do
- {
- result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
- if ( ( result == Result::eSuccess ) && surfaceFormatCount )
- {
- surfaceFormats.resize( surfaceFormatCount );
- result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
- }
- } while ( result == Result::eIncomplete );
- assert( surfaceFormatCount <= surfaceFormats.size() );
- surfaceFormats.resize( surfaceFormatCount );
- return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormatsKHR" );
+ PhysicalDeviceProperties2KHX properties;
+ vkGetPhysicalDeviceProperties2KHX( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHX*>( &properties ) );
+ return properties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHX( const PhysicalDeviceImageFormatInfo2KHX* pImageFormatInfo, ImageFormatProperties2KHX* pImageFormatProperties ) const
{
- return static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
+ return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHX( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHX*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHX*>( pImageFormatProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template <typename Allocator>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface ) const
+ VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2KHX>::type PhysicalDevice::getImageFormatProperties2KHX( const PhysicalDeviceImageFormatInfo2KHX & imageFormatInfo ) const
{
- std::vector<PresentModeKHR,Allocator> presentModes;
- uint32_t presentModeCount;
- Result result;
- do
- {
- result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
- if ( ( result == Result::eSuccess ) && presentModeCount )
- {
- presentModes.resize( presentModeCount );
- result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
- }
- } while ( result == Result::eIncomplete );
- assert( presentModeCount <= presentModes.size() );
- presentModes.resize( presentModeCount );
- return createResultValue( result, presentModes, "vk::PhysicalDevice::getSurfacePresentModesKHR" );
+ ImageFormatProperties2KHX imageFormatProperties;
+ Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHX( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHX*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHX*>( &imageFormatProperties ) ) );
+ return createResultValue( result, imageFormatProperties, "vk::PhysicalDevice::getImageFormatProperties2KHX" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, ExternalBufferPropertiesKHX* pExternalBufferProperties ) const
{
- return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display );
+ vkGetPhysicalDeviceExternalBufferPropertiesKHX( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHX*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferPropertiesKHX*>( pExternalBufferProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const
+ VULKAN_HPP_INLINE ExternalBufferPropertiesKHX PhysicalDevice::getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX & externalBufferInfo ) const
{
- return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
+ ExternalBufferPropertiesKHX externalBufferProperties;
+ vkGetPhysicalDeviceExternalBufferPropertiesKHX( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHX*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferPropertiesKHX*>( &externalBufferProperties ) );
+ return externalBufferProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const
- {
- return vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
- }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_XLIB_KHR
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties ) const
{
- return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID );
+ vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHX*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphorePropertiesKHX*>( pExternalSemaphoreProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const
+ VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHX PhysicalDevice::getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX & externalSemaphoreInfo ) const
{
- return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
+ ExternalSemaphorePropertiesKHX externalSemaphoreProperties;
+ vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHX*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphorePropertiesKHX*>( &externalSemaphoreProperties ) );
+ return externalSemaphoreProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-#ifdef VK_USE_PLATFORM_XCB_KHR
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const
{
- return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id );
+ return static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
}
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const
+#else
+ VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const
{
- return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
+ Result result = static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+ return createResultValue( result, "vk::PhysicalDevice::releaseDisplayEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
- VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display ) const
{
- return static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
+ return static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const
+ VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display ) const
{
- ExternalImageFormatPropertiesNV externalImageFormatProperties;
- Result result = static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
- return createResultValue( result, externalImageFormatProperties, "vk::PhysicalDevice::getExternalImageFormatPropertiesNV" );
+ Display dpy;
+ Result result = static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
+ return createResultValue( result, dpy, "vk::PhysicalDevice::acquireXlibDisplayEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
- VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits ) const
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+ VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay ) const
{
- vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
+ return static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features ) const
+ VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const
{
- DeviceGeneratedCommandsLimitsNVX limits;
- vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
- return limits;
+ DisplayKHR display;
+ Result result = static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
+ return createResultValue( result, display, "vk::PhysicalDevice::getRandROutputDisplayEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
- VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2KHR* pFeatures ) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities ) const
{
- vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( pFeatures ) );
+ return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE PhysicalDeviceFeatures2KHR PhysicalDevice::getFeatures2KHR() const
+ VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface ) const
{
- PhysicalDeviceFeatures2KHR features;
- vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( &features ) );
- return features;
+ SurfaceCapabilities2EXT surfaceCapabilities;
+ Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
+ return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilities2EXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2KHR* pProperties ) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const
{
- vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( pProperties ) );
+ return static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE PhysicalDeviceProperties2KHR PhysicalDevice::getProperties2KHR() const
+ template <typename Allocator>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface ) const
{
- PhysicalDeviceProperties2KHR properties;
- vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( &properties ) );
- return properties;
+ std::vector<Rect2D,Allocator> rects;
+ uint32_t rectCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && rectCount )
+ {
+ rects.resize( rectCount );
+ result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ assert( rectCount <= rects.size() );
+ rects.resize( rectCount );
+ return createResultValue( result, rects, "vk::PhysicalDevice::getPresentRectanglesKHX" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ 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_ )
+ , indirectCommandsLayout( indirectCommandsLayout_ )
+ , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
+ , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
+ , maxSequencesCount( maxSequencesCount_ )
+ , targetCommandBuffer( targetCommandBuffer_ )
+ , sequencesCountBuffer( sequencesCountBuffer_ )
+ , sequencesCountOffset( sequencesCountOffset_ )
+ , sequencesIndexBuffer( sequencesIndexBuffer_ )
+ , sequencesIndexOffset( sequencesIndexOffset_ )
+ {
+ }
+
+ CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) );
+ }
+
+ CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) );
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ )
+ {
+ objectTable = objectTable_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+ {
+ indirectCommandsLayout = indirectCommandsLayout_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ )
+ {
+ indirectCommandsTokenCount = indirectCommandsTokenCount_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
+ {
+ pIndirectCommandsTokens = pIndirectCommandsTokens_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ )
+ {
+ maxSequencesCount = maxSequencesCount_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
+ {
+ targetCommandBuffer = targetCommandBuffer_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
+ {
+ sequencesCountBuffer = sequencesCountBuffer_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
+ {
+ sequencesCountOffset = sequencesCountOffset_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
+ {
+ sequencesIndexBuffer = sequencesIndexBuffer_;
+ return *this;
+ }
+
+ CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
+ {
+ sequencesIndexOffset = sequencesIndexOffset_;
+ return *this;
+ }
+
+ operator const VkCmdProcessCommandsInfoNVX&() const
+ {
+ return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
+ }
+
+ bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( objectTable == rhs.objectTable )
+ && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
+ && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount )
+ && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens )
+ && ( maxSequencesCount == rhs.maxSequencesCount )
+ && ( targetCommandBuffer == rhs.targetCommandBuffer )
+ && ( sequencesCountBuffer == rhs.sequencesCountBuffer )
+ && ( sequencesCountOffset == rhs.sequencesCountOffset )
+ && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer )
+ && ( sequencesIndexOffset == rhs.sequencesIndexOffset );
+ }
- VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2KHR* pFormatProperties ) const
- {
- vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( pFormatProperties ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE FormatProperties2KHR PhysicalDevice::getFormatProperties2KHR( Format format ) const
- {
- FormatProperties2KHR formatProperties;
- vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( &formatProperties ) );
- return formatProperties;
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, ImageFormatProperties2KHR* pImageFormatProperties ) const
- {
- return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( pImageFormatProperties ) ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2KHR>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const
- {
- ImageFormatProperties2KHR imageFormatProperties;
- Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( &imageFormatProperties ) ) );
- return createResultValue( result, imageFormatProperties, "vk::PhysicalDevice::getImageFormatProperties2KHR" );
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ private:
+ StructureType sType;
- VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const
- {
- vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( pQueueFamilyProperties ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template <typename Allocator>
- VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2KHR,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR() const
- {
- std::vector<QueueFamilyProperties2KHR,Allocator> queueFamilyProperties;
- uint32_t queueFamilyPropertyCount;
- vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
- queueFamilyProperties.resize( queueFamilyPropertyCount );
- vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( queueFamilyProperties.data() ) );
- return queueFamilyProperties;
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ public:
+ const void* pNext;
+ ObjectTableNVX objectTable;
+ IndirectCommandsLayoutNVX indirectCommandsLayout;
+ uint32_t indirectCommandsTokenCount;
+ const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
+ uint32_t maxSequencesCount;
+ CommandBuffer targetCommandBuffer;
+ Buffer sequencesCountBuffer;
+ DeviceSize sequencesCountOffset;
+ Buffer sequencesIndexBuffer;
+ DeviceSize sequencesIndexOffset;
+ };
+ static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
- VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const
- {
- vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( pMemoryProperties ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2KHR PhysicalDevice::getMemoryProperties2KHR() const
+ struct PhysicalDeviceGroupPropertiesKHX
{
- PhysicalDeviceMemoryProperties2KHR memoryProperties;
- vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( &memoryProperties ) );
- return memoryProperties;
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ operator const VkPhysicalDeviceGroupPropertiesKHX&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceGroupPropertiesKHX*>(this);
+ }
- VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const
- {
- vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( pProperties ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template <typename Allocator>
- VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2KHR,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const
- {
- std::vector<SparseImageFormatProperties2KHR,Allocator> properties;
- uint32_t propertyCount;
- vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, nullptr );
- properties.resize( propertyCount );
- vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( properties.data() ) );
- return properties;
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ bool operator==( PhysicalDeviceGroupPropertiesKHX const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( physicalDeviceCount == rhs.physicalDeviceCount )
+ && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE_KHX * sizeof( PhysicalDevice ) ) == 0 )
+ && ( subsetAllocation == rhs.subsetAllocation );
+ }
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const
- {
- return static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
- }
-#else
- VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const
- {
- Result result = static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
- return createResultValue( result, "vk::PhysicalDevice::releaseDisplayEXT" );
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ bool operator!=( PhysicalDeviceGroupPropertiesKHX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
- VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display ) const
- {
- return static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display ) const
- {
- Display dpy;
- Result result = static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
- return createResultValue( result, dpy, "vk::PhysicalDevice::acquireXlibDisplayEXT" );
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+ private:
+ StructureType sType;
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
- VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay ) const
- {
- return static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const
- {
- DisplayKHR display;
- Result result = static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
- return createResultValue( result, display, "vk::PhysicalDevice::getRandROutputDisplayEXT" );
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+ public:
+ const void* pNext;
+ uint32_t physicalDeviceCount;
+ PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
+ Bool32 subsetAllocation;
+ };
+ static_assert( sizeof( PhysicalDeviceGroupPropertiesKHX ) == sizeof( VkPhysicalDeviceGroupPropertiesKHX ), "struct and wrapper have different size!" );
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities ) const
- {
- return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface ) const
- {
- SurfaceCapabilities2EXT surfaceCapabilities;
- Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
- return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilities2EXT" );
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class DebugReportCallbackEXTDeleter;
using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, DebugReportCallbackEXTDeleter>;
void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ Result enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator = std::allocator<PhysicalDeviceGroupPropertiesKHX>>
+ typename ResultValueType<std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator>>::type enumeratePhysicalDeviceGroupsKHX() const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ UniqueSurfaceKHR createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ UniqueSurfaceKHR createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
{
return m_instance;
vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- 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_ )
- , indirectCommandsLayout( indirectCommandsLayout_ )
- , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
- , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
- , maxSequencesCount( maxSequencesCount_ )
- , targetCommandBuffer( targetCommandBuffer_ )
- , sequencesCountBuffer( sequencesCountBuffer_ )
- , sequencesCountOffset( sequencesCountOffset_ )
- , sequencesIndexBuffer( sequencesIndexBuffer_ )
- , sequencesIndexOffset( sequencesIndexOffset_ )
- {
- }
-
- CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) );
- }
-
- CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) );
- return *this;
- }
-
- CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
-
- CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ )
- {
- objectTable = objectTable_;
- return *this;
- }
-
- CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
- {
- indirectCommandsLayout = indirectCommandsLayout_;
- return *this;
- }
- CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ )
+ VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const
+ {
+ return static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( pPhysicalDeviceGroupProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator>>::type Instance::enumeratePhysicalDeviceGroupsKHX() const
+ {
+ std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator> physicalDeviceGroupProperties;
+ uint32_t physicalDeviceGroupCount;
+ Result result;
+ do
{
- indirectCommandsTokenCount = indirectCommandsTokenCount_;
- return *this;
- }
+ result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+ {
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( physicalDeviceGroupProperties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ return createResultValue( result, physicalDeviceGroupProperties, "vk::Instance::enumeratePhysicalDeviceGroupsKHX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
- {
- pIndirectCommandsTokens = pIndirectCommandsTokens_;
- return *this;
- }
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
+ {
+ return static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
+ {
+ SurfaceKHR surface;
+ Result result = static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+ return createResultValue( result, surface, "vk::Instance::createIOSSurfaceMVK" );
+ }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ VULKAN_HPP_INLINE UniqueSurfaceKHR Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
+ {
+ SurfaceKHRDeleter deleter( *this, allocator );
+ return UniqueSurfaceKHR( createIOSSurfaceMVK( createInfo, allocator ), deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
- CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ )
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
+ {
+ return static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
+ {
+ SurfaceKHR surface;
+ Result result = static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+ return createResultValue( result, surface, "vk::Instance::createMacOSSurfaceMVK" );
+ }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ VULKAN_HPP_INLINE UniqueSurfaceKHR Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
+ {
+ SurfaceKHRDeleter deleter( *this, allocator );
+ return UniqueSurfaceKHR( createMacOSSurfaceMVK( createInfo, allocator ), deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+ struct DeviceGroupDeviceCreateInfoKHX
+ {
+ DeviceGroupDeviceCreateInfoKHX( uint32_t physicalDeviceCount_ = 0, const PhysicalDevice* pPhysicalDevices_ = nullptr )
+ : sType( StructureType::eDeviceGroupDeviceCreateInfoKHX )
+ , pNext( nullptr )
+ , physicalDeviceCount( physicalDeviceCount_ )
+ , pPhysicalDevices( pPhysicalDevices_ )
{
- maxSequencesCount = maxSequencesCount_;
- return *this;
}
- CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
+ DeviceGroupDeviceCreateInfoKHX( VkDeviceGroupDeviceCreateInfoKHX const & rhs )
{
- targetCommandBuffer = targetCommandBuffer_;
- return *this;
+ memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) );
}
- CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
+ DeviceGroupDeviceCreateInfoKHX& operator=( VkDeviceGroupDeviceCreateInfoKHX const & rhs )
{
- sequencesCountBuffer = sequencesCountBuffer_;
+ memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) );
return *this;
}
- CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
+ DeviceGroupDeviceCreateInfoKHX& setPNext( const void* pNext_ )
{
- sequencesCountOffset = sequencesCountOffset_;
+ pNext = pNext_;
return *this;
}
- CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
+ DeviceGroupDeviceCreateInfoKHX& setPhysicalDeviceCount( uint32_t physicalDeviceCount_ )
{
- sequencesIndexBuffer = sequencesIndexBuffer_;
+ physicalDeviceCount = physicalDeviceCount_;
return *this;
}
- CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
+ DeviceGroupDeviceCreateInfoKHX& setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ )
{
- sequencesIndexOffset = sequencesIndexOffset_;
+ pPhysicalDevices = pPhysicalDevices_;
return *this;
}
- operator const VkCmdProcessCommandsInfoNVX&() const
+ operator const VkDeviceGroupDeviceCreateInfoKHX&() const
{
- return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
+ return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfoKHX*>(this);
}
- bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
+ bool operator==( DeviceGroupDeviceCreateInfoKHX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectTable == rhs.objectTable )
- && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
- && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount )
- && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens )
- && ( maxSequencesCount == rhs.maxSequencesCount )
- && ( targetCommandBuffer == rhs.targetCommandBuffer )
- && ( sequencesCountBuffer == rhs.sequencesCountBuffer )
- && ( sequencesCountOffset == rhs.sequencesCountOffset )
- && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer )
- && ( sequencesIndexOffset == rhs.sequencesIndexOffset );
+ && ( physicalDeviceCount == rhs.physicalDeviceCount )
+ && ( pPhysicalDevices == rhs.pPhysicalDevices );
}
- bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const
+ bool operator!=( DeviceGroupDeviceCreateInfoKHX const& rhs ) const
{
return !operator==( rhs );
}
public:
const void* pNext;
- ObjectTableNVX objectTable;
- IndirectCommandsLayoutNVX indirectCommandsLayout;
- uint32_t indirectCommandsTokenCount;
- const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
- uint32_t maxSequencesCount;
- CommandBuffer targetCommandBuffer;
- Buffer sequencesCountBuffer;
- DeviceSize sequencesCountOffset;
- Buffer sequencesIndexBuffer;
- DeviceSize sequencesIndexOffset;
+ uint32_t physicalDeviceCount;
+ const PhysicalDevice* pPhysicalDevices;
};
- static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupDeviceCreateInfoKHX ) == sizeof( VkDeviceGroupDeviceCreateInfoKHX ), "struct and wrapper have different size!" );
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class InstanceDeleter;
return "{}";
}
- VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits)
- {
- return "(void)";
- }
-
- VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags)
- {
- return "{}";
- }
-
VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits)
{
return "(void)";
return "{}";
}
- VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits)
- {
- return "(void)";
- }
-
- VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags)
- {
- return "{}";
- }
-
VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits)
{
return "(void)";
return "{}";
}
- VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR)
+ VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagBitsKHR)
{
return "(void)";
}
- VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR)
+ VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagsKHR)
{
return "{}";
}
}
#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK)
+ {
+ return "(void)";
+ }
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+ VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK)
+ {
+ return "{}";
+ }
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK)
+ {
+ return "(void)";
+ }
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+ VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK)
+ {
+ return "{}";
+ }
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBitsKHR)
{
return "(void)";
return "{}";
}
+ VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagBitsNV)
+ {
+ return "(void)";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagsNV)
+ {
+ return "{}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT)
+ {
+ return "(void)";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagsEXT)
+ {
+ return "{}";
+ }
+
VULKAN_HPP_INLINE std::string to_string(ImageLayout value)
{
switch (value)
case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
+ case StructureType::eRenderPassMultiviewCreateInfoKHX: return "RenderPassMultiviewCreateInfoKHX";
+ case StructureType::ePhysicalDeviceMultiviewFeaturesKHX: return "PhysicalDeviceMultiviewFeaturesKHX";
+ case StructureType::ePhysicalDeviceMultiviewPropertiesKHX: return "PhysicalDeviceMultiviewPropertiesKHX";
case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
case StructureType::ePhysicalDeviceMemoryProperties2KHR: return "PhysicalDeviceMemoryProperties2KHR";
case StructureType::eSparseImageFormatProperties2KHR: return "SparseImageFormatProperties2KHR";
case StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR: return "PhysicalDeviceSparseImageFormatInfo2KHR";
+ case StructureType::eMemoryAllocateFlagsInfoKHX: return "MemoryAllocateFlagsInfoKHX";
+ case StructureType::eBindBufferMemoryInfoKHX: return "BindBufferMemoryInfoKHX";
+ case StructureType::eBindImageMemoryInfoKHX: return "BindImageMemoryInfoKHX";
+ case StructureType::eDeviceGroupRenderPassBeginInfoKHX: return "DeviceGroupRenderPassBeginInfoKHX";
+ case StructureType::eDeviceGroupCommandBufferBeginInfoKHX: return "DeviceGroupCommandBufferBeginInfoKHX";
+ case StructureType::eDeviceGroupSubmitInfoKHX: return "DeviceGroupSubmitInfoKHX";
+ case StructureType::eDeviceGroupBindSparseInfoKHX: return "DeviceGroupBindSparseInfoKHX";
+ case StructureType::eDeviceGroupPresentCapabilitiesKHX: return "DeviceGroupPresentCapabilitiesKHX";
+ case StructureType::eImageSwapchainCreateInfoKHX: return "ImageSwapchainCreateInfoKHX";
+ case StructureType::eBindImageMemorySwapchainInfoKHX: return "BindImageMemorySwapchainInfoKHX";
+ case StructureType::eAcquireNextImageInfoKHX: return "AcquireNextImageInfoKHX";
+ case StructureType::eDeviceGroupPresentInfoKHX: return "DeviceGroupPresentInfoKHX";
+ case StructureType::eDeviceGroupSwapchainCreateInfoKHX: return "DeviceGroupSwapchainCreateInfoKHX";
case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN";
+ case StructureType::ePhysicalDeviceGroupPropertiesKHX: return "PhysicalDeviceGroupPropertiesKHX";
+ case StructureType::eDeviceGroupDeviceCreateInfoKHX: return "DeviceGroupDeviceCreateInfoKHX";
+ case StructureType::ePhysicalDeviceExternalImageFormatInfoKHX: return "PhysicalDeviceExternalImageFormatInfoKHX";
+ case StructureType::eExternalImageFormatPropertiesKHX: return "ExternalImageFormatPropertiesKHX";
+ case StructureType::ePhysicalDeviceExternalBufferInfoKHX: return "PhysicalDeviceExternalBufferInfoKHX";
+ case StructureType::eExternalBufferPropertiesKHX: return "ExternalBufferPropertiesKHX";
+ case StructureType::ePhysicalDeviceIdPropertiesKHX: return "PhysicalDeviceIdPropertiesKHX";
+ case StructureType::ePhysicalDeviceProperties2KHX: return "PhysicalDeviceProperties2KHX";
+ case StructureType::eImageFormatProperties2KHX: return "ImageFormatProperties2KHX";
+ case StructureType::ePhysicalDeviceImageFormatInfo2KHX: return "PhysicalDeviceImageFormatInfo2KHX";
+ case StructureType::eExternalMemoryBufferCreateInfoKHX: return "ExternalMemoryBufferCreateInfoKHX";
+ case StructureType::eExternalMemoryImageCreateInfoKHX: return "ExternalMemoryImageCreateInfoKHX";
+ case StructureType::eExportMemoryAllocateInfoKHX: return "ExportMemoryAllocateInfoKHX";
+ case StructureType::eImportMemoryWin32HandleInfoKHX: return "ImportMemoryWin32HandleInfoKHX";
+ case StructureType::eExportMemoryWin32HandleInfoKHX: return "ExportMemoryWin32HandleInfoKHX";
+ case StructureType::eMemoryWin32HandlePropertiesKHX: return "MemoryWin32HandlePropertiesKHX";
+ case StructureType::eImportMemoryFdInfoKHX: return "ImportMemoryFdInfoKHX";
+ case StructureType::eMemoryFdPropertiesKHX: return "MemoryFdPropertiesKHX";
+ case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHX: return "Win32KeyedMutexAcquireReleaseInfoKHX";
+ case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHX: return "PhysicalDeviceExternalSemaphoreInfoKHX";
+ case StructureType::eExternalSemaphorePropertiesKHX: return "ExternalSemaphorePropertiesKHX";
+ case StructureType::eExportSemaphoreCreateInfoKHX: return "ExportSemaphoreCreateInfoKHX";
+ case StructureType::eImportSemaphoreWin32HandleInfoKHX: return "ImportSemaphoreWin32HandleInfoKHX";
+ case StructureType::eExportSemaphoreWin32HandleInfoKHX: return "ExportSemaphoreWin32HandleInfoKHX";
+ case StructureType::eD3D12FenceSubmitInfoKHX: return "D3D12FenceSubmitInfoKHX";
+ case StructureType::eImportSemaphoreFdInfoKHX: return "ImportSemaphoreFdInfoKHX";
+ case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR";
+ case StructureType::eDescriptorUpdateTemplateCreateInfoKHR: return "DescriptorUpdateTemplateCreateInfoKHR";
case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX";
case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX";
case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX";
case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX";
case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX";
case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX";
+ case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV";
case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT";
case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT";
case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT";
case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT";
case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT";
+ case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
+ case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV";
+ case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT";
+ case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT";
+ case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK";
+ case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK";
default: return "invalid";
}
}
case DynamicState::eStencilCompareMask: return "StencilCompareMask";
case DynamicState::eStencilWriteMask: return "StencilWriteMask";
case DynamicState::eStencilReference: return "StencilReference";
+ case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
+ case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateTypeKHR value)
+ {
+ switch (value)
+ {
+ case DescriptorUpdateTemplateTypeKHR::eDescriptorSet: return "DescriptorSet";
+ case DescriptorUpdateTemplateTypeKHR::ePushDescriptors: return "PushDescriptors";
default: return "invalid";
}
}
switch (value)
{
case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal";
+ case MemoryHeapFlagBits::eMultiInstanceKHX: return "MultiInstanceKHX";
default: return "invalid";
}
}
if (!value) return "{}";
std::string result;
if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | ";
+ if (value & MemoryHeapFlagBits::eMultiInstanceKHX) result += "MultiInstanceKHX | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case ImageCreateFlagBits::eSparseAliased: return "SparseAliased";
case ImageCreateFlagBits::eMutableFormat: return "MutableFormat";
case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible";
+ case ImageCreateFlagBits::eBindSfrKHX: return "BindSfrKHX";
case ImageCreateFlagBits::e2DArrayCompatibleKHR: return "2DArrayCompatibleKHR";
default: return "invalid";
}
if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | ";
if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | ";
+ if (value & ImageCreateFlagBits::eBindSfrKHX) result += "BindSfrKHX | ";
if (value & ImageCreateFlagBits::e2DArrayCompatibleKHR) result += "2DArrayCompatibleKHR | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization";
case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives";
case PipelineCreateFlagBits::eDerivative: return "Derivative";
+ case PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX: return "ViewIndexFromDeviceIndexKHX";
+ case PipelineCreateFlagBits::eDispatchBaseKHX: return "DispatchBaseKHX";
default: return "invalid";
}
}
if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | ";
if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | ";
if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | ";
+ if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) result += "ViewIndexFromDeviceIndexKHX | ";
+ if (value & PipelineCreateFlagBits::eDispatchBaseKHX) result += "DispatchBaseKHX | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
switch (value)
{
case DependencyFlagBits::eByRegion: return "ByRegion";
+ case DependencyFlagBits::eViewLocalKHX: return "ViewLocalKHX";
+ case DependencyFlagBits::eDeviceGroupKHX: return "DeviceGroupKHX";
default: return "invalid";
}
}
if (!value) return "{}";
std::string result;
if (value & DependencyFlagBits::eByRegion) result += "ByRegion | ";
+ if (value & DependencyFlagBits::eViewLocalKHX) result += "ViewLocalKHX | ";
+ if (value & DependencyFlagBits::eDeviceGroupKHX) result += "DeviceGroupKHX | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
}
}
+ VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits value)
+ {
+ switch (value)
+ {
+ case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) result += "PushDescriptorKHR | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd: return "OpaqueFd";
+ case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32: return "OpaqueWin32";
+ case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
+ case ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture: return "D3D11Texture";
+ case ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt: return "D3D11TextureKmt";
+ case ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap: return "D3D12Heap";
+ case ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource: return "D3D12Resource";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd) result += "OpaqueFd | ";
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32) result += "OpaqueWin32 | ";
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture) result += "D3D11Texture | ";
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt) result += "D3D11TextureKmt | ";
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap) result += "D3D12Heap | ";
+ if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource) result += "D3D12Resource | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly: return "DedicatedOnly";
+ case ExternalMemoryFeatureFlagBitsKHX::eExportable: return "Exportable";
+ case ExternalMemoryFeatureFlagBitsKHX::eImportable: return "Importable";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly) result += "DedicatedOnly | ";
+ if (value & ExternalMemoryFeatureFlagBitsKHX::eExportable) result += "Exportable | ";
+ if (value & ExternalMemoryFeatureFlagBitsKHX::eImportable) result += "Importable | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd: return "OpaqueFd";
+ case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32: return "OpaqueWin32";
+ case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
+ case ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence: return "D3D12Fence";
+ case ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd: return "FenceFd";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd) result += "OpaqueFd | ";
+ if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32) result += "OpaqueWin32 | ";
+ if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
+ if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence) result += "D3D12Fence | ";
+ if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd) result += "FenceFd | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case ExternalSemaphoreFeatureFlagBitsKHX::eExportable: return "Exportable";
+ case ExternalSemaphoreFeatureFlagBitsKHX::eImportable: return "Importable";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & ExternalSemaphoreFeatureFlagBitsKHX::eExportable) result += "Exportable | ";
+ if (value & ExternalSemaphoreFeatureFlagBitsKHX::eImportable) result += "Importable | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value)
{
switch (value)
}
}
+ VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case PeerMemoryFeatureFlagBitsKHX::eCopySrc: return "CopySrc";
+ case PeerMemoryFeatureFlagBitsKHX::eCopyDst: return "CopyDst";
+ case PeerMemoryFeatureFlagBitsKHX::eGenericSrc: return "GenericSrc";
+ case PeerMemoryFeatureFlagBitsKHX::eGenericDst: return "GenericDst";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & PeerMemoryFeatureFlagBitsKHX::eCopySrc) result += "CopySrc | ";
+ if (value & PeerMemoryFeatureFlagBitsKHX::eCopyDst) result += "CopyDst | ";
+ if (value & PeerMemoryFeatureFlagBitsKHX::eGenericSrc) result += "GenericSrc | ";
+ if (value & PeerMemoryFeatureFlagBitsKHX::eGenericDst) result += "GenericDst | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case MemoryAllocateFlagBitsKHX::eDeviceMask: return "DeviceMask";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & MemoryAllocateFlagBitsKHX::eDeviceMask) result += "DeviceMask | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagBitsKHX value)
+ {
+ switch (value)
+ {
+ case DeviceGroupPresentModeFlagBitsKHX::eLocal: return "Local";
+ case DeviceGroupPresentModeFlagBitsKHX::eRemote: return "Remote";
+ case DeviceGroupPresentModeFlagBitsKHX::eSum: return "Sum";
+ case DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice: return "LocalMultiDevice";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHX value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & DeviceGroupPresentModeFlagBitsKHX::eLocal) result += "Local | ";
+ if (value & DeviceGroupPresentModeFlagBitsKHX::eRemote) result += "Remote | ";
+ if (value & DeviceGroupPresentModeFlagBitsKHX::eSum) result += "Sum | ";
+ if (value & DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice) result += "LocalMultiDevice | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR value)
+ {
+ switch (value)
+ {
+ case SwapchainCreateFlagBitsKHR::eBindSfrKHX: return "BindSfrKHX";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & SwapchainCreateFlagBitsKHR::eBindSfrKHX) result += "BindSfrKHX | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value)
+ {
+ switch (value)
+ {
+ case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX";
+ case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX";
+ case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY";
+ case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY";
+ case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ";
+ case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ";
+ case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW";
+ case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value)
+ {
+ switch (value)
+ {
+ case DiscardRectangleModeEXT::eInclusive: return "Inclusive";
+ case DiscardRectangleModeEXT::eExclusive: return "Exclusive";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value)
+ {
+ switch (value)
+ {
+ case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX";
+ case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | ";
+ if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
} // namespace vk
#endif
projects / platform / upstream / Vulkan-Tools.git / commitdiff