#include <cstddef>
#include <cstdint>
#include <cstring>
+#include <functional>
#include <initializer_list>
#include <string>
#include <system_error>
# include <compare>
#endif
-static_assert( VK_HEADER_VERSION == 136 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 137 , "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
};
#endif
+ template <typename T, size_t N>
+ class ArrayWrapper1D : public std::array<T,N>
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT
+ : std::array<T, N>()
+ {}
+
+ VULKAN_HPP_CONSTEXPR ArrayWrapper1D(std::array<T,N> const& data) VULKAN_HPP_NOEXCEPT
+ : std::array<T, N>(data)
+ {}
+
+#if defined(_WIN32) && !defined(_WIN64)
+ VULKAN_HPP_CONSTEXPR T const& operator[](int index) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::array<T, N>::operator[](index);
+ }
+
+ VULKAN_HPP_CONSTEXPR T & operator[](int index) VULKAN_HPP_NOEXCEPT
+ {
+ return std::array<T, N>::operator[](index);
+ }
+#endif
+
+ operator T const* () const VULKAN_HPP_NOEXCEPT
+ {
+ return this->data();
+ }
+
+ operator T * () VULKAN_HPP_NOEXCEPT
+ {
+ return this->data();
+ }
+ };
+
+ // specialization of relational operators between std::string and arrays of chars
+ template <size_t N>
+ bool operator<(std::string const& lhs, ArrayWrapper1D<char, N> const& rhs) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs < rhs.data();
+ }
+
+ template <size_t N>
+ bool operator<=(std::string const& lhs, ArrayWrapper1D<char, N> const& rhs) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs <= rhs.data();
+ }
+
+ template <size_t N>
+ bool operator>(std::string const& lhs, ArrayWrapper1D<char, N> const& rhs) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs > rhs.data();
+ }
+
+ template <size_t N>
+ bool operator>=(std::string const& lhs, ArrayWrapper1D<char, N> const& rhs) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs >= rhs.data();
+ }
+
+ template <size_t N>
+ bool operator==(std::string const& lhs, ArrayWrapper1D<char, N> const& rhs) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs == rhs.data();
+ }
+
+ template <size_t N>
+ bool operator!=(std::string const& lhs, ArrayWrapper1D<char, N> const& rhs) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs != rhs.data();
+ }
+
+ template <typename T, size_t N, size_t M>
+ class ArrayWrapper2D : public std::array<ArrayWrapper1D<T,M>,N>
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT
+ : std::array<ArrayWrapper1D<T,M>, N>()
+ {}
+
+ VULKAN_HPP_CONSTEXPR ArrayWrapper2D(std::array<std::array<T,M>,N> const& data) VULKAN_HPP_NOEXCEPT
+ : std::array<ArrayWrapper1D<T,M>, N>(*reinterpret_cast<std::array<ArrayWrapper1D<T,M>,N> const*>(&data))
+ {}
+ };
+
template <typename FlagBitsType> struct FlagTraits
{
enum { allFlags = 0 };
return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
}
+ VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
+ }
+
uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX* pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageViewHandleNVX( device, pInfo );
Dispatch const* m_dispatch;
};
- template<typename T, size_t N, size_t I>
- class PrivateConstExpression1DArrayCopy
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T * dst, T const* src ) VULKAN_HPP_NOEXCEPT
- {
- PrivateConstExpression1DArrayCopy<T, N, I - 1>::copy( dst, src );
- dst[I - 1] = src[I - 1];
- }
- };
-
- template<typename T, size_t N>
- class PrivateConstExpression1DArrayCopy<T, N, 0>
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T * /*dst*/, T const* /*src*/ ) VULKAN_HPP_NOEXCEPT
- {}
- };
-
- template <typename T, size_t N>
- class ConstExpression1DArrayCopy
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T dst[N], const T src[N] ) VULKAN_HPP_NOEXCEPT
- {
- const size_t C = N / 2;
- PrivateConstExpression1DArrayCopy<T, C, C>::copy( dst, src );
- PrivateConstExpression1DArrayCopy<T, N - C, N - C>::copy(dst + C, src + C);
- }
-
- VULKAN_HPP_CONSTEXPR_14 static void copy( T dst[N], std::array<T, N> const& src ) VULKAN_HPP_NOEXCEPT
- {
- const size_t C = N / 2;
- PrivateConstExpression1DArrayCopy<T, C, C>::copy(dst, src.data());
- PrivateConstExpression1DArrayCopy<T, N - C, N - C>::copy(dst + C, src.data() + C);
- }
- };
-
- template<typename T, size_t N, size_t M, size_t I, size_t J>
- class PrivateConstExpression2DArrayCopy
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T * dst, T const* src ) VULKAN_HPP_NOEXCEPT
- {
- PrivateConstExpression2DArrayCopy<T, N, M, I, J - 1>::copy( dst, src );
- dst[(I - 1) * M + J - 1] = src[(I - 1) * M + J - 1];
- }
- };
-
- template<typename T, size_t N, size_t M, size_t I>
- class PrivateConstExpression2DArrayCopy<T, N, M, I,0>
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T * dst, T const* src ) VULKAN_HPP_NOEXCEPT
- {
- PrivateConstExpression2DArrayCopy<T, N, M, I - 1, M>::copy( dst, src );
- }
- };
-
- template<typename T, size_t N, size_t M, size_t J>
- class PrivateConstExpression2DArrayCopy<T, N, M, 0, J>
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T * /*dst*/, T const* /*src*/ ) VULKAN_HPP_NOEXCEPT
- {}
- };
-
- template <typename T, size_t N, size_t M>
- class ConstExpression2DArrayCopy
- {
- public:
- VULKAN_HPP_CONSTEXPR_14 static void copy( T dst[N][M], const T src[N][M] ) VULKAN_HPP_NOEXCEPT
- {
- PrivateConstExpression2DArrayCopy<T, N, M, N, M>::copy( &dst[0][0], &src[0][0] );
- }
-
- VULKAN_HPP_CONSTEXPR_14 static void copy( T dst[N][M], std::array<std::array<T, M>, N> const& src ) VULKAN_HPP_NOEXCEPT
- {
- PrivateConstExpression2DArrayCopy<T, N, M, N, M>::copy( &dst[0][0], src.data()->data() );
- }
- };
-
using Bool32 = uint32_t;
using DeviceAddress = uint64_t;
using DeviceSize = uint64_t;
enum class AttachmentStoreOp
{
eStore = VK_ATTACHMENT_STORE_OP_STORE,
- eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE
+ eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+ eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM
};
VULKAN_HPP_INLINE std::string to_string( AttachmentStoreOp value )
{
case AttachmentStoreOp::eStore : return "Store";
case AttachmentStoreOp::eDontCare : return "DontCare";
+ case AttachmentStoreOp::eNoneQCOM : return "NoneQCOM";
default: return "invalid";
}
}
ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX,
+ eImageViewAddressPropertiesNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
eStreamDescriptorSurfaceCreateInfoGGP = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
eAccelerationStructureGeometryInstancesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
eAccelerationStructureGeometryTrianglesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
eAccelerationStructureGeometryKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
- eAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_KHR,
eAccelerationStructureMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR,
eAccelerationStructureVersionKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_KHR,
eCopyAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR,
case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT";
case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT";
case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX";
+ case StructureType::eImageViewAddressPropertiesNVX : return "ImageViewAddressPropertiesNVX";
case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD";
case StructureType::eStreamDescriptorSurfaceCreateInfoGGP : return "StreamDescriptorSurfaceCreateInfoGGP";
case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV : return "PhysicalDeviceCornerSampledImageFeaturesNV";
case StructureType::eAccelerationStructureGeometryInstancesDataKHR : return "AccelerationStructureGeometryInstancesDataKHR";
case StructureType::eAccelerationStructureGeometryTrianglesDataKHR : return "AccelerationStructureGeometryTrianglesDataKHR";
case StructureType::eAccelerationStructureGeometryKHR : return "AccelerationStructureGeometryKHR";
- case StructureType::eAccelerationStructureInfoKHR : return "AccelerationStructureInfoKHR";
case StructureType::eAccelerationStructureMemoryRequirementsInfoKHR : return "AccelerationStructureMemoryRequirementsInfoKHR";
case StructureType::eAccelerationStructureVersionKHR : return "AccelerationStructureVersionKHR";
case StructureType::eCopyAccelerationStructureInfoKHR : return "CopyAccelerationStructureInfoKHR";
T value;
operator std::tuple<Result&, T&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, T&>(result, value); }
+
+#if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
+ operator T const& () const VULKAN_HPP_NOEXCEPT
+ {
+ return value;
+ }
+
+ operator T& () VULKAN_HPP_NOEXCEPT
+ {
+ return value;
+ }
+#endif
+ };
+
+#if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
+ template <typename Type, typename Dispatch>
+ struct ResultValue<UniqueHandle<Type,Dispatch>>
+ {
+#ifdef VULKAN_HPP_HAS_NOEXCEPT
+ ResultValue(Result r, UniqueHandle<Type, Dispatch> & v) VULKAN_HPP_NOEXCEPT
+#else
+ ResultValue(Result r, UniqueHandle<Type, Dispatch>& v)
+#endif
+ : result(r)
+ , value(v)
+ {}
+
+#ifdef VULKAN_HPP_HAS_NOEXCEPT
+ ResultValue(Result r, UniqueHandle<Type, Dispatch> && v) VULKAN_HPP_NOEXCEPT
+#else
+ ResultValue(Result r, UniqueHandle<Type, Dispatch> && v)
+#endif
+ : result(r)
+ , value(std::move(v))
+ {}
+
+ Result result;
+ UniqueHandle<Type, Dispatch> value;
+
+ operator std::tuple<Result&, UniqueHandle<Type, Dispatch>&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, UniqueHandle<Type, Dispatch>&>(result, value); }
+
+ operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT
+ {
+ return std::move(value);
+ }
};
+#endif
template <typename T>
struct ResultValueType
return UniqueHandle<T,D>(data, deleter);
#endif
}
+
+ template <typename T, typename D>
+ VULKAN_HPP_INLINE ResultValue<UniqueHandle<T,D>> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes, typename UniqueHandleTraits<T,D>::deleter const& deleter )
+ {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ ignore(message);
+ VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+ return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
+#else
+ if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+ {
+ throwResultException( result, message );
+ }
+ return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
+#endif
+ }
#endif
struct AabbPositionsKHR;
struct ImageSubresourceRange;
struct ImageSwapchainCreateInfoKHR;
struct ImageViewASTCDecodeModeEXT;
+ struct ImageViewAddressPropertiesNVX;
struct ImageViewCreateInfo;
struct ImageViewHandleInfoNVX;
struct ImageViewUsageCreateInfo;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
, maxZ( maxZ_ )
{}
- VULKAN_HPP_CONSTEXPR AabbPositionsKHR( AabbPositionsKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : minX( rhs.minX )
- , minY( rhs.minY )
- , minZ( rhs.minZ )
- , maxX( rhs.maxX )
- , maxY( rhs.maxY )
- , maxZ( rhs.maxZ )
- {}
-
- AabbPositionsKHR & operator=( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AabbPositionsKHR ) );
- return *this;
- }
-
AabbPositionsKHR( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, transformData( transformData_ )
{}
- AccelerationStructureGeometryTrianglesDataKHR( AccelerationStructureGeometryTrianglesDataKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , vertexFormat( rhs.vertexFormat )
- , vertexData( rhs.vertexData )
- , vertexStride( rhs.vertexStride )
- , indexType( rhs.indexType )
- , indexData( rhs.indexData )
- , transformData( rhs.transformData )
- {}
-
AccelerationStructureGeometryTrianglesDataKHR & operator=( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureGeometryTrianglesDataKHR ) - offsetof( AccelerationStructureGeometryTrianglesDataKHR, pNext ) );
, stride( stride_ )
{}
- AccelerationStructureGeometryAabbsDataKHR( AccelerationStructureGeometryAabbsDataKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , data( rhs.data )
- , stride( rhs.stride )
- {}
-
AccelerationStructureGeometryAabbsDataKHR & operator=( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureGeometryAabbsDataKHR ) - offsetof( AccelerationStructureGeometryAabbsDataKHR, pNext ) );
, data( data_ )
{}
- AccelerationStructureGeometryInstancesDataKHR( AccelerationStructureGeometryInstancesDataKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , arrayOfPointers( rhs.arrayOfPointers )
- , data( rhs.data )
- {}
-
AccelerationStructureGeometryInstancesDataKHR & operator=( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureGeometryInstancesDataKHR ) - offsetof( AccelerationStructureGeometryInstancesDataKHR, pNext ) );
, flags( flags_ )
{}
- AccelerationStructureGeometryKHR( AccelerationStructureGeometryKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , geometryType( rhs.geometryType )
- , geometry( rhs.geometry )
- , flags( rhs.flags )
- {}
-
AccelerationStructureGeometryKHR & operator=( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureGeometryKHR ) - offsetof( AccelerationStructureGeometryKHR, pNext ) );
, scratchData( scratchData_ )
{}
- AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureBuildGeometryInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , flags( rhs.flags )
- , update( rhs.update )
- , srcAccelerationStructure( rhs.srcAccelerationStructure )
- , dstAccelerationStructure( rhs.dstAccelerationStructure )
- , geometryArrayOfPointers( rhs.geometryArrayOfPointers )
- , geometryCount( rhs.geometryCount )
- , ppGeometries( rhs.ppGeometries )
- , scratchData( rhs.scratchData )
- {}
-
AccelerationStructureBuildGeometryInfoKHR & operator=( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureBuildGeometryInfoKHR ) - offsetof( AccelerationStructureBuildGeometryInfoKHR, pNext ) );
, transformOffset( transformOffset_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureBuildOffsetInfoKHR( AccelerationStructureBuildOffsetInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : primitiveCount( rhs.primitiveCount )
- , primitiveOffset( rhs.primitiveOffset )
- , firstVertex( rhs.firstVertex )
- , transformOffset( rhs.transformOffset )
- {}
-
- AccelerationStructureBuildOffsetInfoKHR & operator=( AccelerationStructureBuildOffsetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AccelerationStructureBuildOffsetInfoKHR ) );
- return *this;
- }
-
AccelerationStructureBuildOffsetInfoKHR( VkAccelerationStructureBuildOffsetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, allowsTransforms( allowsTransforms_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureCreateGeometryTypeInfoKHR( AccelerationStructureCreateGeometryTypeInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , geometryType( rhs.geometryType )
- , maxPrimitiveCount( rhs.maxPrimitiveCount )
- , indexType( rhs.indexType )
- , maxVertexCount( rhs.maxVertexCount )
- , vertexFormat( rhs.vertexFormat )
- , allowsTransforms( rhs.allowsTransforms )
- {}
-
AccelerationStructureCreateGeometryTypeInfoKHR & operator=( AccelerationStructureCreateGeometryTypeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureCreateGeometryTypeInfoKHR ) - offsetof( AccelerationStructureCreateGeometryTypeInfoKHR, pNext ) );
, deviceAddress( deviceAddress_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , compactedSize( rhs.compactedSize )
- , type( rhs.type )
- , flags( rhs.flags )
- , maxGeometryCount( rhs.maxGeometryCount )
- , pGeometryInfos( rhs.pGeometryInfos )
- , deviceAddress( rhs.deviceAddress )
- {}
-
AccelerationStructureCreateInfoKHR & operator=( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureCreateInfoKHR ) - offsetof( AccelerationStructureCreateInfoKHR, pNext ) );
, transformOffset( transformOffset_ )
{}
- VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( GeometryTrianglesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , vertexData( rhs.vertexData )
- , vertexOffset( rhs.vertexOffset )
- , vertexCount( rhs.vertexCount )
- , vertexStride( rhs.vertexStride )
- , vertexFormat( rhs.vertexFormat )
- , indexData( rhs.indexData )
- , indexOffset( rhs.indexOffset )
- , indexCount( rhs.indexCount )
- , indexType( rhs.indexType )
- , transformData( rhs.transformData )
- , transformOffset( rhs.transformOffset )
- {}
-
GeometryTrianglesNV & operator=( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GeometryTrianglesNV ) - offsetof( GeometryTrianglesNV, pNext ) );
, offset( offset_ )
{}
- VULKAN_HPP_CONSTEXPR GeometryAABBNV( GeometryAABBNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , aabbData( rhs.aabbData )
- , numAABBs( rhs.numAABBs )
- , stride( rhs.stride )
- , offset( rhs.offset )
- {}
-
GeometryAABBNV & operator=( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GeometryAABBNV ) - offsetof( GeometryAABBNV, pNext ) );
, aabbs( aabbs_ )
{}
- VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryDataNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : triangles( rhs.triangles )
- , aabbs( rhs.aabbs )
- {}
-
- GeometryDataNV & operator=( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( GeometryDataNV ) );
- return *this;
- }
-
GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR GeometryNV( GeometryNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , geometryType( rhs.geometryType )
- , geometry( rhs.geometry )
- , flags( rhs.flags )
- {}
-
GeometryNV & operator=( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GeometryNV ) - offsetof( GeometryNV, pNext ) );
, pGeometries( pGeometries_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , flags( rhs.flags )
- , instanceCount( rhs.instanceCount )
- , geometryCount( rhs.geometryCount )
- , pGeometries( rhs.pGeometries )
- {}
-
AccelerationStructureInfoNV & operator=( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureInfoNV ) - offsetof( AccelerationStructureInfoNV, pNext ) );
, info( info_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( AccelerationStructureCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , compactedSize( rhs.compactedSize )
- , info( rhs.info )
- {}
-
AccelerationStructureCreateInfoNV & operator=( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureCreateInfoNV ) - offsetof( AccelerationStructureCreateInfoNV, pNext ) );
: accelerationStructure( accelerationStructure_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureDeviceAddressInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , accelerationStructure( rhs.accelerationStructure )
- {}
-
AccelerationStructureDeviceAddressInfoKHR & operator=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureDeviceAddressInfoKHR ) - offsetof( AccelerationStructureDeviceAddressInfoKHR, pNext ) );
struct TransformMatrixKHR
{
VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( std::array<std::array<float,4>,3> const& matrix_ = {} ) VULKAN_HPP_NOEXCEPT
- : matrix{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression2DArrayCopy<float,3,4>::copy( matrix, matrix_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( TransformMatrixKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : matrix{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression2DArrayCopy<float,3,4>::copy( matrix, rhs.matrix );
- }
-
- TransformMatrixKHR & operator=( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( TransformMatrixKHR ) );
- return *this;
- }
+ : matrix( matrix_ )
+ {}
TransformMatrixKHR( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
TransformMatrixKHR & setMatrix( std::array<std::array<float,4>,3> matrix_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( matrix, matrix_.data(), 3 * 4 * sizeof( float ) );
+ matrix = matrix_;
return *this;
}
#else
bool operator==( TransformMatrixKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( memcmp( matrix, rhs.matrix, 3 * 4 * sizeof( float ) ) == 0 );
+ return ( matrix == rhs.matrix );
}
bool operator!=( TransformMatrixKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
#endif
public:
- float matrix[3][4] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper2D<float, 3, 4> matrix = {};
};
static_assert( sizeof( TransformMatrixKHR ) == sizeof( VkTransformMatrixKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<TransformMatrixKHR>::value, "struct wrapper is not a standard layout!" );
, accelerationStructureReference( accelerationStructureReference_ )
{}
- VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( AccelerationStructureInstanceKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : transform( rhs.transform )
- , instanceCustomIndex( rhs.instanceCustomIndex )
- , mask( rhs.mask )
- , instanceShaderBindingTableRecordOffset( rhs.instanceShaderBindingTableRecordOffset )
- , flags( rhs.flags )
- , accelerationStructureReference( rhs.accelerationStructureReference )
- {}
-
- AccelerationStructureInstanceKHR & operator=( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AccelerationStructureInstanceKHR ) );
- return *this;
- }
-
AccelerationStructureInstanceKHR( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, accelerationStructure( accelerationStructure_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoKHR( AccelerationStructureMemoryRequirementsInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , buildType( rhs.buildType )
- , accelerationStructure( rhs.accelerationStructure )
- {}
-
AccelerationStructureMemoryRequirementsInfoKHR & operator=( AccelerationStructureMemoryRequirementsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureMemoryRequirementsInfoKHR ) - offsetof( AccelerationStructureMemoryRequirementsInfoKHR, pNext ) );
, accelerationStructure( accelerationStructure_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , accelerationStructure( rhs.accelerationStructure )
- {}
-
AccelerationStructureMemoryRequirementsInfoNV & operator=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) - offsetof( AccelerationStructureMemoryRequirementsInfoNV, pNext ) );
: versionData( versionData_ )
{}
- VULKAN_HPP_CONSTEXPR AccelerationStructureVersionKHR( AccelerationStructureVersionKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , versionData( rhs.versionData )
- {}
-
AccelerationStructureVersionKHR & operator=( AccelerationStructureVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AccelerationStructureVersionKHR ) - offsetof( AccelerationStructureVersionKHR, pNext ) );
, deviceMask( deviceMask_ )
{}
- VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( AcquireNextImageInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , swapchain( rhs.swapchain )
- , timeout( rhs.timeout )
- , semaphore( rhs.semaphore )
- , fence( rhs.fence )
- , deviceMask( rhs.deviceMask )
- {}
-
AcquireNextImageInfoKHR & operator=( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AcquireNextImageInfoKHR ) - offsetof( AcquireNextImageInfoKHR, pNext ) );
, timeout( timeout_ )
{}
- VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( AcquireProfilingLockInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , timeout( rhs.timeout )
- {}
-
AcquireProfilingLockInfoKHR & operator=( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AcquireProfilingLockInfoKHR ) - offsetof( AcquireProfilingLockInfoKHR, pNext ) );
, pfnInternalFree( pfnInternalFree_ )
{}
- VULKAN_HPP_CONSTEXPR AllocationCallbacks( AllocationCallbacks const& rhs ) VULKAN_HPP_NOEXCEPT
- : pUserData( rhs.pUserData )
- , pfnAllocation( rhs.pfnAllocation )
- , pfnReallocation( rhs.pfnReallocation )
- , pfnFree( rhs.pfnFree )
- , pfnInternalAllocation( rhs.pfnInternalAllocation )
- , pfnInternalFree( rhs.pfnInternalFree )
- {}
-
- AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AllocationCallbacks ) );
- return *this;
- }
-
AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, a( a_ )
{}
- VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentMapping const& rhs ) VULKAN_HPP_NOEXCEPT
- : r( rhs.r )
- , g( rhs.g )
- , b( rhs.b )
- , a( rhs.a )
- {}
-
- ComponentMapping & operator=( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ComponentMapping ) );
- return *this;
- }
-
ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, suggestedYChromaOffset( suggestedYChromaOffset_ )
{}
- VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , format( rhs.format )
- , externalFormat( rhs.externalFormat )
- , formatFeatures( rhs.formatFeatures )
- , samplerYcbcrConversionComponents( rhs.samplerYcbcrConversionComponents )
- , suggestedYcbcrModel( rhs.suggestedYcbcrModel )
- , suggestedYcbcrRange( rhs.suggestedYcbcrRange )
- , suggestedXChromaOffset( rhs.suggestedXChromaOffset )
- , suggestedYChromaOffset( rhs.suggestedYChromaOffset )
- {}
-
AndroidHardwareBufferFormatPropertiesANDROID & operator=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) - offsetof( AndroidHardwareBufferFormatPropertiesANDROID, pNext ) );
, memoryTypeBits( memoryTypeBits_ )
{}
- VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( AndroidHardwareBufferPropertiesANDROID const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , allocationSize( rhs.allocationSize )
- , memoryTypeBits( rhs.memoryTypeBits )
- {}
-
AndroidHardwareBufferPropertiesANDROID & operator=( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AndroidHardwareBufferPropertiesANDROID ) - offsetof( AndroidHardwareBufferPropertiesANDROID, pNext ) );
: androidHardwareBufferUsage( androidHardwareBufferUsage_ )
{}
- VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( AndroidHardwareBufferUsageANDROID const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , androidHardwareBufferUsage( rhs.androidHardwareBufferUsage )
- {}
-
AndroidHardwareBufferUsageANDROID & operator=( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AndroidHardwareBufferUsageANDROID ) - offsetof( AndroidHardwareBufferUsageANDROID, pNext ) );
, window( window_ )
{}
- VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , window( rhs.window )
- {}
-
AndroidSurfaceCreateInfoKHR & operator=( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AndroidSurfaceCreateInfoKHR ) - offsetof( AndroidSurfaceCreateInfoKHR, pNext ) );
, apiVersion( apiVersion_ )
{}
- VULKAN_HPP_CONSTEXPR ApplicationInfo( ApplicationInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pApplicationName( rhs.pApplicationName )
- , applicationVersion( rhs.applicationVersion )
- , pEngineName( rhs.pEngineName )
- , engineVersion( rhs.engineVersion )
- , apiVersion( rhs.apiVersion )
- {}
-
ApplicationInfo & operator=( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ApplicationInfo ) - offsetof( ApplicationInfo, pNext ) );
, finalLayout( finalLayout_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescription const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
- AttachmentDescription & operator=( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AttachmentDescription ) );
- return *this;
- }
-
AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, finalLayout( finalLayout_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescription2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , 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 )
- {}
-
AttachmentDescription2 & operator=( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AttachmentDescription2 ) - offsetof( AttachmentDescription2, pNext ) );
, stencilFinalLayout( stencilFinalLayout_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( AttachmentDescriptionStencilLayout const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , stencilInitialLayout( rhs.stencilInitialLayout )
- , stencilFinalLayout( rhs.stencilFinalLayout )
- {}
-
AttachmentDescriptionStencilLayout & operator=( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AttachmentDescriptionStencilLayout ) - offsetof( AttachmentDescriptionStencilLayout, pNext ) );
, layout( layout_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentReference( AttachmentReference const& rhs ) VULKAN_HPP_NOEXCEPT
- : attachment( rhs.attachment )
- , layout( rhs.layout )
- {}
-
- AttachmentReference & operator=( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AttachmentReference ) );
- return *this;
- }
-
AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, aspectMask( aspectMask_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentReference2( AttachmentReference2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , attachment( rhs.attachment )
- , layout( rhs.layout )
- , aspectMask( rhs.aspectMask )
- {}
-
AttachmentReference2 & operator=( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AttachmentReference2 ) - offsetof( AttachmentReference2, pNext ) );
: stencilLayout( stencilLayout_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( AttachmentReferenceStencilLayout const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , stencilLayout( rhs.stencilLayout )
- {}
-
AttachmentReferenceStencilLayout & operator=( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( AttachmentReferenceStencilLayout ) - offsetof( AttachmentReferenceStencilLayout, pNext ) );
, height( height_ )
{}
- VULKAN_HPP_CONSTEXPR Extent2D( Extent2D const& rhs ) VULKAN_HPP_NOEXCEPT
- : width( rhs.width )
- , height( rhs.height )
- {}
-
- Extent2D & operator=( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( Extent2D ) );
- return *this;
- }
-
Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, y( y_ )
{}
- VULKAN_HPP_CONSTEXPR SampleLocationEXT( SampleLocationEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- {}
-
- SampleLocationEXT & operator=( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SampleLocationEXT ) );
- return *this;
- }
-
SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pSampleLocations( pSampleLocations_ )
{}
- VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleLocationsInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , sampleLocationsPerPixel( rhs.sampleLocationsPerPixel )
- , sampleLocationGridSize( rhs.sampleLocationGridSize )
- , sampleLocationsCount( rhs.sampleLocationsCount )
- , pSampleLocations( rhs.pSampleLocations )
- {}
-
SampleLocationsInfoEXT & operator=( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SampleLocationsInfoEXT ) - offsetof( SampleLocationsInfoEXT, pNext ) );
, sampleLocationsInfo( sampleLocationsInfo_ )
{}
- VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( AttachmentSampleLocationsEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : attachmentIndex( rhs.attachmentIndex )
- , sampleLocationsInfo( rhs.sampleLocationsInfo )
- {}
-
- AttachmentSampleLocationsEXT & operator=( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( AttachmentSampleLocationsEXT ) );
- return *this;
- }
-
AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
BaseInStructure() VULKAN_HPP_NOEXCEPT
{}
- BaseInStructure( BaseInStructure const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- {}
-
- BaseInStructure & operator=( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BaseInStructure ) );
- return *this;
- }
-
BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
BaseOutStructure() VULKAN_HPP_NOEXCEPT
{}
- BaseOutStructure( BaseOutStructure const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- {}
-
- BaseOutStructure & operator=( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BaseOutStructure ) );
- return *this;
- }
-
BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pDeviceIndices( pDeviceIndices_ )
{}
- VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoKHR( BindAccelerationStructureMemoryInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , accelerationStructure( rhs.accelerationStructure )
- , memory( rhs.memory )
- , memoryOffset( rhs.memoryOffset )
- , deviceIndexCount( rhs.deviceIndexCount )
- , pDeviceIndices( rhs.pDeviceIndices )
- {}
-
BindAccelerationStructureMemoryInfoKHR & operator=( BindAccelerationStructureMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindAccelerationStructureMemoryInfoKHR ) - offsetof( BindAccelerationStructureMemoryInfoKHR, pNext ) );
, pDeviceIndices( pDeviceIndices_ )
{}
- VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( BindBufferMemoryDeviceGroupInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceIndexCount( rhs.deviceIndexCount )
- , pDeviceIndices( rhs.pDeviceIndices )
- {}
-
BindBufferMemoryDeviceGroupInfo & operator=( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindBufferMemoryDeviceGroupInfo ) - offsetof( BindBufferMemoryDeviceGroupInfo, pNext ) );
, memoryOffset( memoryOffset_ )
{}
- VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( BindBufferMemoryInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , buffer( rhs.buffer )
- , memory( rhs.memory )
- , memoryOffset( rhs.memoryOffset )
- {}
-
BindBufferMemoryInfo & operator=( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindBufferMemoryInfo ) - offsetof( BindBufferMemoryInfo, pNext ) );
, y( y_ )
{}
- VULKAN_HPP_CONSTEXPR Offset2D( Offset2D const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- {}
-
- Offset2D & operator=( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( Offset2D ) );
- return *this;
- }
-
Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, extent( extent_ )
{}
- VULKAN_HPP_CONSTEXPR Rect2D( Rect2D const& rhs ) VULKAN_HPP_NOEXCEPT
- : offset( rhs.offset )
- , extent( rhs.extent )
- {}
-
- Rect2D & operator=( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( Rect2D ) );
- return *this;
- }
-
Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
{}
- VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( BindImageMemoryDeviceGroupInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceIndexCount( rhs.deviceIndexCount )
- , pDeviceIndices( rhs.pDeviceIndices )
- , splitInstanceBindRegionCount( rhs.splitInstanceBindRegionCount )
- , pSplitInstanceBindRegions( rhs.pSplitInstanceBindRegions )
- {}
-
BindImageMemoryDeviceGroupInfo & operator=( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindImageMemoryDeviceGroupInfo ) - offsetof( BindImageMemoryDeviceGroupInfo, pNext ) );
, memoryOffset( memoryOffset_ )
{}
- VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( BindImageMemoryInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , image( rhs.image )
- , memory( rhs.memory )
- , memoryOffset( rhs.memoryOffset )
- {}
-
BindImageMemoryInfo & operator=( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindImageMemoryInfo ) - offsetof( BindImageMemoryInfo, pNext ) );
, imageIndex( imageIndex_ )
{}
- VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( BindImageMemorySwapchainInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , swapchain( rhs.swapchain )
- , imageIndex( rhs.imageIndex )
- {}
-
BindImageMemorySwapchainInfoKHR & operator=( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindImageMemorySwapchainInfoKHR ) - offsetof( BindImageMemorySwapchainInfoKHR, pNext ) );
: planeAspect( planeAspect_ )
{}
- VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( BindImagePlaneMemoryInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , planeAspect( rhs.planeAspect )
- {}
-
BindImagePlaneMemoryInfo & operator=( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindImagePlaneMemoryInfo ) - offsetof( BindImagePlaneMemoryInfo, pNext ) );
, indexType( indexType_ )
{}
- VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( BindIndexBufferIndirectCommandNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : bufferAddress( rhs.bufferAddress )
- , size( rhs.size )
- , indexType( rhs.indexType )
- {}
-
- BindIndexBufferIndirectCommandNV & operator=( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BindIndexBufferIndirectCommandNV ) );
- return *this;
- }
-
BindIndexBufferIndirectCommandNV( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: groupIndex( groupIndex_ )
{}
- VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( BindShaderGroupIndirectCommandNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : groupIndex( rhs.groupIndex )
- {}
-
- BindShaderGroupIndirectCommandNV & operator=( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BindShaderGroupIndirectCommandNV ) );
- return *this;
- }
-
BindShaderGroupIndirectCommandNV( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR SparseMemoryBind( SparseMemoryBind const& rhs ) VULKAN_HPP_NOEXCEPT
- : resourceOffset( rhs.resourceOffset )
- , size( rhs.size )
- , memory( rhs.memory )
- , memoryOffset( rhs.memoryOffset )
- , flags( rhs.flags )
- {}
-
- SparseMemoryBind & operator=( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseMemoryBind ) );
- return *this;
- }
-
SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pBinds( pBinds_ )
{}
- VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( SparseBufferMemoryBindInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : buffer( rhs.buffer )
- , bindCount( rhs.bindCount )
- , pBinds( rhs.pBinds )
- {}
-
- SparseBufferMemoryBindInfo & operator=( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseBufferMemoryBindInfo ) );
- return *this;
- }
-
SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pBinds( pBinds_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( SparseImageOpaqueMemoryBindInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : image( rhs.image )
- , bindCount( rhs.bindCount )
- , pBinds( rhs.pBinds )
- {}
-
- SparseImageOpaqueMemoryBindInfo & operator=( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
- return *this;
- }
-
SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, arrayLayer( arrayLayer_ )
{}
- VULKAN_HPP_CONSTEXPR ImageSubresource( ImageSubresource const& rhs ) VULKAN_HPP_NOEXCEPT
- : aspectMask( rhs.aspectMask )
- , mipLevel( rhs.mipLevel )
- , arrayLayer( rhs.arrayLayer )
- {}
-
- ImageSubresource & operator=( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageSubresource ) );
- return *this;
- }
-
ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, z( z_ )
{}
- VULKAN_HPP_CONSTEXPR Offset3D( Offset3D const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- , z( rhs.z )
- {}
-
explicit Offset3D( Offset2D const& offset2D,
int32_t z_ = {} )
: x( offset2D.x )
, z( z_ )
{}
- Offset3D & operator=( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( Offset3D ) );
- return *this;
- }
-
Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, depth( depth_ )
{}
- VULKAN_HPP_CONSTEXPR Extent3D( Extent3D const& rhs ) VULKAN_HPP_NOEXCEPT
- : width( rhs.width )
- , height( rhs.height )
- , depth( rhs.depth )
- {}
-
explicit Extent3D( Extent2D const& extent2D,
uint32_t depth_ = {} )
: width( extent2D.width )
, depth( depth_ )
{}
- Extent3D & operator=( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( Extent3D ) );
- return *this;
- }
-
Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( SparseImageMemoryBind const& rhs ) VULKAN_HPP_NOEXCEPT
- : subresource( rhs.subresource )
- , offset( rhs.offset )
- , extent( rhs.extent )
- , memory( rhs.memory )
- , memoryOffset( rhs.memoryOffset )
- , flags( rhs.flags )
- {}
-
- SparseImageMemoryBind & operator=( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseImageMemoryBind ) );
- return *this;
- }
-
SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pBinds( pBinds_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( SparseImageMemoryBindInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : image( rhs.image )
- , bindCount( rhs.bindCount )
- , pBinds( rhs.pBinds )
- {}
-
- SparseImageMemoryBindInfo & operator=( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseImageMemoryBindInfo ) );
- return *this;
- }
-
SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pSignalSemaphores( pSignalSemaphores_ )
{}
- VULKAN_HPP_CONSTEXPR BindSparseInfo( BindSparseInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
BindSparseInfo & operator=( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BindSparseInfo ) - offsetof( BindSparseInfo, pNext ) );
, stride( stride_ )
{}
- VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( BindVertexBufferIndirectCommandNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : bufferAddress( rhs.bufferAddress )
- , size( rhs.size )
- , stride( rhs.stride )
- {}
-
- BindVertexBufferIndirectCommandNV & operator=( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BindVertexBufferIndirectCommandNV ) );
- return *this;
- }
-
BindVertexBufferIndirectCommandNV( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, size( size_ )
{}
- VULKAN_HPP_CONSTEXPR BufferCopy( BufferCopy const& rhs ) VULKAN_HPP_NOEXCEPT
- : srcOffset( rhs.srcOffset )
- , dstOffset( rhs.dstOffset )
- , size( rhs.size )
- {}
-
- BufferCopy & operator=( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BufferCopy ) );
- return *this;
- }
-
BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pQueueFamilyIndices( pQueueFamilyIndices_ )
{}
- VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , size( rhs.size )
- , usage( rhs.usage )
- , sharingMode( rhs.sharingMode )
- , queueFamilyIndexCount( rhs.queueFamilyIndexCount )
- , pQueueFamilyIndices( rhs.pQueueFamilyIndices )
- {}
-
BufferCreateInfo & operator=( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferCreateInfo ) - offsetof( BufferCreateInfo, pNext ) );
: deviceAddress( deviceAddress_ )
{}
- VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( BufferDeviceAddressCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceAddress( rhs.deviceAddress )
- {}
-
BufferDeviceAddressCreateInfoEXT & operator=( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferDeviceAddressCreateInfoEXT ) - offsetof( BufferDeviceAddressCreateInfoEXT, pNext ) );
: buffer( buffer_ )
{}
- VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( BufferDeviceAddressInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , buffer( rhs.buffer )
- {}
-
BufferDeviceAddressInfo & operator=( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferDeviceAddressInfo ) - offsetof( BufferDeviceAddressInfo, pNext ) );
, layerCount( layerCount_ )
{}
- VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageSubresourceLayers const& rhs ) VULKAN_HPP_NOEXCEPT
- : aspectMask( rhs.aspectMask )
- , mipLevel( rhs.mipLevel )
- , baseArrayLayer( rhs.baseArrayLayer )
- , layerCount( rhs.layerCount )
- {}
-
- ImageSubresourceLayers & operator=( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageSubresourceLayers ) );
- return *this;
- }
-
ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, imageExtent( imageExtent_ )
{}
- VULKAN_HPP_CONSTEXPR BufferImageCopy( BufferImageCopy const& rhs ) VULKAN_HPP_NOEXCEPT
- : bufferOffset( rhs.bufferOffset )
- , bufferRowLength( rhs.bufferRowLength )
- , bufferImageHeight( rhs.bufferImageHeight )
- , imageSubresource( rhs.imageSubresource )
- , imageOffset( rhs.imageOffset )
- , imageExtent( rhs.imageExtent )
- {}
-
- BufferImageCopy & operator=( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( BufferImageCopy ) );
- return *this;
- }
-
BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, size( size_ )
{}
- VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( BufferMemoryBarrier const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , srcAccessMask( rhs.srcAccessMask )
- , dstAccessMask( rhs.dstAccessMask )
- , srcQueueFamilyIndex( rhs.srcQueueFamilyIndex )
- , dstQueueFamilyIndex( rhs.dstQueueFamilyIndex )
- , buffer( rhs.buffer )
- , offset( rhs.offset )
- , size( rhs.size )
- {}
-
BufferMemoryBarrier & operator=( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferMemoryBarrier ) - offsetof( BufferMemoryBarrier, pNext ) );
: buffer( buffer_ )
{}
- VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( BufferMemoryRequirementsInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , buffer( rhs.buffer )
- {}
-
BufferMemoryRequirementsInfo2 & operator=( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferMemoryRequirementsInfo2 ) - offsetof( BufferMemoryRequirementsInfo2, pNext ) );
: opaqueCaptureAddress( opaqueCaptureAddress_ )
{}
- VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( BufferOpaqueCaptureAddressCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , opaqueCaptureAddress( rhs.opaqueCaptureAddress )
- {}
-
BufferOpaqueCaptureAddressCreateInfo & operator=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferOpaqueCaptureAddressCreateInfo ) - offsetof( BufferOpaqueCaptureAddressCreateInfo, pNext ) );
, range( range_ )
{}
- VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , buffer( rhs.buffer )
- , format( rhs.format )
- , offset( rhs.offset )
- , range( rhs.range )
- {}
-
BufferViewCreateInfo & operator=( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( BufferViewCreateInfo ) - offsetof( BufferViewCreateInfo, pNext ) );
: timeDomain( timeDomain_ )
{}
- VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( CalibratedTimestampInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , timeDomain( rhs.timeDomain )
- {}
-
CalibratedTimestampInfoEXT & operator=( CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CalibratedTimestampInfoEXT ) - offsetof( CalibratedTimestampInfoEXT, pNext ) );
, pCheckpointMarker( pCheckpointMarker_ )
{}
- VULKAN_HPP_CONSTEXPR CheckpointDataNV( CheckpointDataNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , stage( rhs.stage )
- , pCheckpointMarker( rhs.pCheckpointMarker )
- {}
-
CheckpointDataNV & operator=( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CheckpointDataNV ) - offsetof( CheckpointDataNV, pNext ) );
ClearColorValue( const std::array<float,4>& float32_ = {} )
{
- memcpy( float32, float32_.data(), 4 * sizeof( float ) );
+ float32 = float32_;
}
ClearColorValue( const std::array<int32_t,4>& int32_ )
{
- memcpy( int32, int32_.data(), 4 * sizeof( int32_t ) );
+ int32 = int32_;
}
ClearColorValue( const std::array<uint32_t,4>& uint32_ )
{
- memcpy( uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
+ uint32 = uint32_;
}
ClearColorValue & setFloat32( std::array<float,4> float32_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( float32, float32_.data(), 4 * sizeof( float ) );
+ float32 = float32_;
return *this;
}
ClearColorValue & setInt32( std::array<int32_t,4> int32_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( int32, int32_.data(), 4 * sizeof( int32_t ) );
+ int32 = int32_;
return *this;
}
ClearColorValue & setUint32( std::array<uint32_t,4> uint32_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
+ uint32 = uint32_;
return *this;
}
return *reinterpret_cast<VkClearColorValue*>(this);
}
- float float32[4];
- int32_t int32[4];
- uint32_t uint32[4];
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> float32;
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, 4> int32;
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 4> uint32;
};
struct ClearDepthStencilValue
, stencil( stencil_ )
{}
- VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( ClearDepthStencilValue const& rhs ) VULKAN_HPP_NOEXCEPT
- : depth( rhs.depth )
- , stencil( rhs.stencil )
- {}
-
- ClearDepthStencilValue & operator=( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ClearDepthStencilValue ) );
- return *this;
- }
-
ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, clearValue( clearValue_ )
{}
- ClearAttachment( ClearAttachment const& rhs ) VULKAN_HPP_NOEXCEPT
- : aspectMask( rhs.aspectMask )
- , colorAttachment( rhs.colorAttachment )
- , clearValue( rhs.clearValue )
- {}
-
- ClearAttachment & operator=( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ClearAttachment ) );
- return *this;
- }
-
ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, layerCount( layerCount_ )
{}
- VULKAN_HPP_CONSTEXPR ClearRect( ClearRect const& rhs ) VULKAN_HPP_NOEXCEPT
- : rect( rhs.rect )
- , baseArrayLayer( rhs.baseArrayLayer )
- , layerCount( rhs.layerCount )
- {}
-
- ClearRect & operator=( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ClearRect ) );
- return *this;
- }
-
ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, sample( sample_ )
{}
- VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( CoarseSampleLocationNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pixelX( rhs.pixelX )
- , pixelY( rhs.pixelY )
- , sample( rhs.sample )
- {}
-
- CoarseSampleLocationNV & operator=( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( CoarseSampleLocationNV ) );
- return *this;
- }
-
CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pSampleLocations( pSampleLocations_ )
{}
- VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( CoarseSampleOrderCustomNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : shadingRate( rhs.shadingRate )
- , sampleCount( rhs.sampleCount )
- , sampleLocationCount( rhs.sampleLocationCount )
- , pSampleLocations( rhs.pSampleLocations )
- {}
-
- CoarseSampleOrderCustomNV & operator=( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( CoarseSampleOrderCustomNV ) );
- return *this;
- }
-
CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, commandBufferCount( commandBufferCount_ )
{}
- VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandBufferAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , commandPool( rhs.commandPool )
- , level( rhs.level )
- , commandBufferCount( rhs.commandBufferCount )
- {}
-
CommandBufferAllocateInfo & operator=( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferAllocateInfo ) - offsetof( CommandBufferAllocateInfo, pNext ) );
, pipelineStatistics( pipelineStatistics_ )
{}
- VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( CommandBufferInheritanceInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , renderPass( rhs.renderPass )
- , subpass( rhs.subpass )
- , framebuffer( rhs.framebuffer )
- , occlusionQueryEnable( rhs.occlusionQueryEnable )
- , queryFlags( rhs.queryFlags )
- , pipelineStatistics( rhs.pipelineStatistics )
- {}
-
CommandBufferInheritanceInfo & operator=( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferInheritanceInfo ) - offsetof( CommandBufferInheritanceInfo, pNext ) );
, pInheritanceInfo( pInheritanceInfo_ )
{}
- VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pInheritanceInfo( rhs.pInheritanceInfo )
- {}
-
CommandBufferBeginInfo & operator=( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferBeginInfo ) - offsetof( CommandBufferBeginInfo, pNext ) );
: conditionalRenderingEnable( conditionalRenderingEnable_ )
{}
- VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , conditionalRenderingEnable( rhs.conditionalRenderingEnable )
- {}
-
CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) - offsetof( CommandBufferInheritanceConditionalRenderingInfoEXT, pNext ) );
, renderArea( renderArea_ )
{}
- VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( CommandBufferInheritanceRenderPassTransformInfoQCOM const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , transform( rhs.transform )
- , renderArea( rhs.renderArea )
- {}
-
CommandBufferInheritanceRenderPassTransformInfoQCOM & operator=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferInheritanceRenderPassTransformInfoQCOM ) - offsetof( CommandBufferInheritanceRenderPassTransformInfoQCOM, pNext ) );
, queueFamilyIndex( queueFamilyIndex_ )
{}
- VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( CommandPoolCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , queueFamilyIndex( rhs.queueFamilyIndex )
- {}
-
CommandPoolCreateInfo & operator=( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CommandPoolCreateInfo ) - offsetof( CommandPoolCreateInfo, pNext ) );
, size( size_ )
{}
- VULKAN_HPP_CONSTEXPR SpecializationMapEntry( SpecializationMapEntry const& rhs ) VULKAN_HPP_NOEXCEPT
- : constantID( rhs.constantID )
- , offset( rhs.offset )
- , size( rhs.size )
- {}
-
- SpecializationMapEntry & operator=( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SpecializationMapEntry ) );
- return *this;
- }
-
SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pData( pData_ )
{}
- VULKAN_HPP_CONSTEXPR SpecializationInfo( SpecializationInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : mapEntryCount( rhs.mapEntryCount )
- , pMapEntries( rhs.pMapEntries )
- , dataSize( rhs.dataSize )
- , pData( rhs.pData )
- {}
-
- SpecializationInfo & operator=( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SpecializationInfo ) );
- return *this;
- }
-
SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pSpecializationInfo( pSpecializationInfo_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , stage( rhs.stage )
- , module( rhs.module )
- , pName( rhs.pName )
- , pSpecializationInfo( rhs.pSpecializationInfo )
- {}
-
PipelineShaderStageCreateInfo & operator=( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineShaderStageCreateInfo ) - offsetof( PipelineShaderStageCreateInfo, pNext ) );
, basePipelineIndex( basePipelineIndex_ )
{}
- VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( ComputePipelineCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , stage( rhs.stage )
- , layout( rhs.layout )
- , basePipelineHandle( rhs.basePipelineHandle )
- , basePipelineIndex( rhs.basePipelineIndex )
- {}
-
ComputePipelineCreateInfo & operator=( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ComputePipelineCreateInfo ) - offsetof( ComputePipelineCreateInfo, pNext ) );
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( ConditionalRenderingBeginInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , buffer( rhs.buffer )
- , offset( rhs.offset )
- , flags( rhs.flags )
- {}
-
ConditionalRenderingBeginInfoEXT & operator=( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ConditionalRenderingBeginInfoEXT ) - offsetof( ConditionalRenderingBeginInfoEXT, pNext ) );
, patch( patch_ )
{}
- VULKAN_HPP_CONSTEXPR ConformanceVersion( ConformanceVersion const& rhs ) VULKAN_HPP_NOEXCEPT
- : major( rhs.major )
- , minor( rhs.minor )
- , subminor( rhs.subminor )
- , patch( rhs.patch )
- {}
-
- ConformanceVersion & operator=( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ConformanceVersion ) );
- return *this;
- }
-
ConformanceVersion( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, scope( scope_ )
{}
- VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , MSize( rhs.MSize )
- , NSize( rhs.NSize )
- , KSize( rhs.KSize )
- , AType( rhs.AType )
- , BType( rhs.BType )
- , CType( rhs.CType )
- , DType( rhs.DType )
- , scope( rhs.scope )
- {}
-
CooperativeMatrixPropertiesNV & operator=( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CooperativeMatrixPropertiesNV ) - offsetof( CooperativeMatrixPropertiesNV, pNext ) );
, mode( mode_ )
{}
- VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( CopyAccelerationStructureInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , src( rhs.src )
- , dst( rhs.dst )
- , mode( rhs.mode )
- {}
-
CopyAccelerationStructureInfoKHR & operator=( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CopyAccelerationStructureInfoKHR ) - offsetof( CopyAccelerationStructureInfoKHR, pNext ) );
, mode( mode_ )
{}
- CopyAccelerationStructureToMemoryInfoKHR( CopyAccelerationStructureToMemoryInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , src( rhs.src )
- , dst( rhs.dst )
- , mode( rhs.mode )
- {}
-
CopyAccelerationStructureToMemoryInfoKHR & operator=( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CopyAccelerationStructureToMemoryInfoKHR ) - offsetof( CopyAccelerationStructureToMemoryInfoKHR, pNext ) );
, descriptorCount( descriptorCount_ )
{}
- VULKAN_HPP_CONSTEXPR CopyDescriptorSet( CopyDescriptorSet const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , srcSet( rhs.srcSet )
- , srcBinding( rhs.srcBinding )
- , srcArrayElement( rhs.srcArrayElement )
- , dstSet( rhs.dstSet )
- , dstBinding( rhs.dstBinding )
- , dstArrayElement( rhs.dstArrayElement )
- , descriptorCount( rhs.descriptorCount )
- {}
-
CopyDescriptorSet & operator=( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CopyDescriptorSet ) - offsetof( CopyDescriptorSet, pNext ) );
, mode( mode_ )
{}
- CopyMemoryToAccelerationStructureInfoKHR( CopyMemoryToAccelerationStructureInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , src( rhs.src )
- , dst( rhs.dst )
- , mode( rhs.mode )
- {}
-
CopyMemoryToAccelerationStructureInfoKHR & operator=( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( CopyMemoryToAccelerationStructureInfoKHR ) - offsetof( CopyMemoryToAccelerationStructureInfoKHR, pNext ) );
, pSignalSemaphoreValues( pSignalSemaphoreValues_ )
{}
- VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( D3D12FenceSubmitInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , waitSemaphoreValuesCount( rhs.waitSemaphoreValuesCount )
- , pWaitSemaphoreValues( rhs.pWaitSemaphoreValues )
- , signalSemaphoreValuesCount( rhs.signalSemaphoreValuesCount )
- , pSignalSemaphoreValues( rhs.pSignalSemaphoreValues )
- {}
-
D3D12FenceSubmitInfoKHR & operator=( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( D3D12FenceSubmitInfoKHR ) - offsetof( D3D12FenceSubmitInfoKHR, pNext ) );
VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = {},
std::array<float,4> const& color_ = {} ) VULKAN_HPP_NOEXCEPT
: pMarkerName( pMarkerName_ )
- , color{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( color, color_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( DebugMarkerMarkerInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pMarkerName( rhs.pMarkerName )
- , color{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( color, rhs.color );
- }
+ , color( color_ )
+ {}
DebugMarkerMarkerInfoEXT & operator=( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
DebugMarkerMarkerInfoEXT & setColor( std::array<float,4> color_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( color, color_.data(), 4 * sizeof( float ) );
+ color = color_;
return *this;
}
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( pMarkerName == rhs.pMarkerName )
- && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
+ && ( color == rhs.color );
}
bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
const void* pNext = {};
const char* pMarkerName = {};
- float color[4] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> color = {};
};
static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DebugMarkerMarkerInfoEXT>::value, "struct wrapper is not a standard layout!" );
, pObjectName( pObjectName_ )
{}
- VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugMarkerObjectNameInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , objectType( rhs.objectType )
- , object( rhs.object )
- , pObjectName( rhs.pObjectName )
- {}
-
DebugMarkerObjectNameInfoEXT & operator=( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugMarkerObjectNameInfoEXT ) - offsetof( DebugMarkerObjectNameInfoEXT, pNext ) );
, pTag( pTag_ )
{}
- VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugMarkerObjectTagInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , objectType( rhs.objectType )
- , object( rhs.object )
- , tagName( rhs.tagName )
- , tagSize( rhs.tagSize )
- , pTag( rhs.pTag )
- {}
-
DebugMarkerObjectTagInfoEXT & operator=( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugMarkerObjectTagInfoEXT ) - offsetof( DebugMarkerObjectTagInfoEXT, pNext ) );
, pUserData( pUserData_ )
{}
- VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportCallbackCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pfnCallback( rhs.pfnCallback )
- , pUserData( rhs.pUserData )
- {}
-
DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugReportCallbackCreateInfoEXT ) - offsetof( DebugReportCallbackCreateInfoEXT, pNext ) );
VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = {},
std::array<float,4> const& color_ = {} ) VULKAN_HPP_NOEXCEPT
: pLabelName( pLabelName_ )
- , color{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( color, color_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( DebugUtilsLabelEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pLabelName( rhs.pLabelName )
- , color{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( color, rhs.color );
- }
+ , color( color_ )
+ {}
DebugUtilsLabelEXT & operator=( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
DebugUtilsLabelEXT & setColor( std::array<float,4> color_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( color, color_.data(), 4 * sizeof( float ) );
+ color = color_;
return *this;
}
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( pLabelName == rhs.pLabelName )
- && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
+ && ( color == rhs.color );
}
bool operator!=( DebugUtilsLabelEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsLabelEXT;
const void* pNext = {};
const char* pLabelName = {};
- float color[4] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> color = {};
};
static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DebugUtilsLabelEXT>::value, "struct wrapper is not a standard layout!" );
, pObjectName( pObjectName_ )
{}
- VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( DebugUtilsObjectNameInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , objectType( rhs.objectType )
- , objectHandle( rhs.objectHandle )
- , pObjectName( rhs.pObjectName )
- {}
-
DebugUtilsObjectNameInfoEXT & operator=( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugUtilsObjectNameInfoEXT ) - offsetof( DebugUtilsObjectNameInfoEXT, pNext ) );
, pObjects( pObjects_ )
{}
- VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pMessageIdName( rhs.pMessageIdName )
- , messageIdNumber( rhs.messageIdNumber )
- , pMessage( rhs.pMessage )
- , queueLabelCount( rhs.queueLabelCount )
- , pQueueLabels( rhs.pQueueLabels )
- , cmdBufLabelCount( rhs.cmdBufLabelCount )
- , pCmdBufLabels( rhs.pCmdBufLabels )
- , objectCount( rhs.objectCount )
- , pObjects( rhs.pObjects )
- {}
-
DebugUtilsMessengerCallbackDataEXT & operator=( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugUtilsMessengerCallbackDataEXT ) - offsetof( DebugUtilsMessengerCallbackDataEXT, pNext ) );
, pUserData( pUserData_ )
{}
- VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , messageSeverity( rhs.messageSeverity )
- , messageType( rhs.messageType )
- , pfnUserCallback( rhs.pfnUserCallback )
- , pUserData( rhs.pUserData )
- {}
-
DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugUtilsMessengerCreateInfoEXT ) - offsetof( DebugUtilsMessengerCreateInfoEXT, pNext ) );
, pTag( pTag_ )
{}
- VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( DebugUtilsObjectTagInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , objectType( rhs.objectType )
- , objectHandle( rhs.objectHandle )
- , tagName( rhs.tagName )
- , tagSize( rhs.tagSize )
- , pTag( rhs.pTag )
- {}
-
DebugUtilsObjectTagInfoEXT & operator=( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DebugUtilsObjectTagInfoEXT ) - offsetof( DebugUtilsObjectTagInfoEXT, pNext ) );
: dedicatedAllocation( dedicatedAllocation_ )
{}
- VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( DedicatedAllocationBufferCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , dedicatedAllocation( rhs.dedicatedAllocation )
- {}
-
DedicatedAllocationBufferCreateInfoNV & operator=( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DedicatedAllocationBufferCreateInfoNV ) - offsetof( DedicatedAllocationBufferCreateInfoNV, pNext ) );
: dedicatedAllocation( dedicatedAllocation_ )
{}
- VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( DedicatedAllocationImageCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , dedicatedAllocation( rhs.dedicatedAllocation )
- {}
-
DedicatedAllocationImageCreateInfoNV & operator=( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DedicatedAllocationImageCreateInfoNV ) - offsetof( DedicatedAllocationImageCreateInfoNV, pNext ) );
, buffer( buffer_ )
{}
- VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , image( rhs.image )
- , buffer( rhs.buffer )
- {}
-
DedicatedAllocationMemoryAllocateInfoNV & operator=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) - offsetof( DedicatedAllocationMemoryAllocateInfoNV, pNext ) );
: operationHandle( operationHandle_ )
{}
- VULKAN_HPP_CONSTEXPR DeferredOperationInfoKHR( DeferredOperationInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , operationHandle( rhs.operationHandle )
- {}
-
DeferredOperationInfoKHR & operator=( DeferredOperationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeferredOperationInfoKHR ) - offsetof( DeferredOperationInfoKHR, pNext ) );
, range( range_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( DescriptorBufferInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : buffer( rhs.buffer )
- , offset( rhs.offset )
- , range( rhs.range )
- {}
-
- DescriptorBufferInfo & operator=( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorBufferInfo ) );
- return *this;
- }
-
DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, imageLayout( imageLayout_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorImageInfo( DescriptorImageInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : sampler( rhs.sampler )
- , imageView( rhs.imageView )
- , imageLayout( rhs.imageLayout )
- {}
-
- DescriptorImageInfo & operator=( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorImageInfo ) );
- return *this;
- }
-
DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, descriptorCount( descriptorCount_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorPoolSize const& rhs ) VULKAN_HPP_NOEXCEPT
- : type( rhs.type )
- , descriptorCount( rhs.descriptorCount )
- {}
-
- DescriptorPoolSize & operator=( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorPoolSize ) );
- return *this;
- }
-
DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pPoolSizes( pPoolSizes_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , maxSets( rhs.maxSets )
- , poolSizeCount( rhs.poolSizeCount )
- , pPoolSizes( rhs.pPoolSizes )
- {}
-
DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorPoolCreateInfo ) - offsetof( DescriptorPoolCreateInfo, pNext ) );
: maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxInlineUniformBlockBindings( rhs.maxInlineUniformBlockBindings )
- {}
-
DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) - offsetof( DescriptorPoolInlineUniformBlockCreateInfoEXT, pNext ) );
, pSetLayouts( pSetLayouts_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorSetAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , descriptorPool( rhs.descriptorPool )
- , descriptorSetCount( rhs.descriptorSetCount )
- , pSetLayouts( rhs.pSetLayouts )
- {}
-
DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetAllocateInfo ) - offsetof( DescriptorSetAllocateInfo, pNext ) );
, pImmutableSamplers( pImmutableSamplers_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( DescriptorSetLayoutBinding const& rhs ) VULKAN_HPP_NOEXCEPT
- : binding( rhs.binding )
- , descriptorType( rhs.descriptorType )
- , descriptorCount( rhs.descriptorCount )
- , stageFlags( rhs.stageFlags )
- , pImmutableSamplers( rhs.pImmutableSamplers )
- {}
-
- DescriptorSetLayoutBinding & operator=( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorSetLayoutBinding ) );
- return *this;
- }
-
DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pBindingFlags( pBindingFlags_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( DescriptorSetLayoutBindingFlagsCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , bindingCount( rhs.bindingCount )
- , pBindingFlags( rhs.pBindingFlags )
- {}
-
DescriptorSetLayoutBindingFlagsCreateInfo & operator=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutBindingFlagsCreateInfo ) - offsetof( DescriptorSetLayoutBindingFlagsCreateInfo, pNext ) );
, pBindings( pBindings_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , bindingCount( rhs.bindingCount )
- , pBindings( rhs.pBindings )
- {}
-
DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutCreateInfo ) - offsetof( DescriptorSetLayoutCreateInfo, pNext ) );
: supported( supported_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( DescriptorSetLayoutSupport const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , supported( rhs.supported )
- {}
-
DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutSupport ) - offsetof( DescriptorSetLayoutSupport, pNext ) );
, pDescriptorCounts( pDescriptorCounts_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( DescriptorSetVariableDescriptorCountAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , descriptorSetCount( rhs.descriptorSetCount )
- , pDescriptorCounts( rhs.pDescriptorCounts )
- {}
-
DescriptorSetVariableDescriptorCountAllocateInfo & operator=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetVariableDescriptorCountAllocateInfo ) - offsetof( DescriptorSetVariableDescriptorCountAllocateInfo, pNext ) );
: maxVariableDescriptorCount( maxVariableDescriptorCount_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( DescriptorSetVariableDescriptorCountLayoutSupport const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxVariableDescriptorCount( rhs.maxVariableDescriptorCount )
- {}
-
DescriptorSetVariableDescriptorCountLayoutSupport & operator=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetVariableDescriptorCountLayoutSupport ) - offsetof( DescriptorSetVariableDescriptorCountLayoutSupport, pNext ) );
, stride( stride_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( DescriptorUpdateTemplateEntry const& rhs ) VULKAN_HPP_NOEXCEPT
- : dstBinding( rhs.dstBinding )
- , dstArrayElement( rhs.dstArrayElement )
- , descriptorCount( rhs.descriptorCount )
- , descriptorType( rhs.descriptorType )
- , offset( rhs.offset )
- , stride( rhs.stride )
- {}
-
- DescriptorUpdateTemplateEntry & operator=( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
- return *this;
- }
-
DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, set( set_ )
{}
- VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , descriptorUpdateEntryCount( rhs.descriptorUpdateEntryCount )
- , pDescriptorUpdateEntries( rhs.pDescriptorUpdateEntries )
- , templateType( rhs.templateType )
- , descriptorSetLayout( rhs.descriptorSetLayout )
- , pipelineBindPoint( rhs.pipelineBindPoint )
- , pipelineLayout( rhs.pipelineLayout )
- , set( rhs.set )
- {}
-
DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorUpdateTemplateCreateInfo ) - offsetof( DescriptorUpdateTemplateCreateInfo, pNext ) );
, pQueuePriorities( pQueuePriorities_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , queueFamilyIndex( rhs.queueFamilyIndex )
- , queueCount( rhs.queueCount )
- , pQueuePriorities( rhs.pQueuePriorities )
- {}
-
DeviceQueueCreateInfo & operator=( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceQueueCreateInfo ) - offsetof( DeviceQueueCreateInfo, pNext ) );
, inheritedQueries( inheritedQueries_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( PhysicalDeviceFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : robustBufferAccess( rhs.robustBufferAccess )
- , fullDrawIndexUint32( rhs.fullDrawIndexUint32 )
- , imageCubeArray( rhs.imageCubeArray )
- , independentBlend( rhs.independentBlend )
- , geometryShader( rhs.geometryShader )
- , tessellationShader( rhs.tessellationShader )
- , sampleRateShading( rhs.sampleRateShading )
- , dualSrcBlend( rhs.dualSrcBlend )
- , logicOp( rhs.logicOp )
- , multiDrawIndirect( rhs.multiDrawIndirect )
- , drawIndirectFirstInstance( rhs.drawIndirectFirstInstance )
- , depthClamp( rhs.depthClamp )
- , depthBiasClamp( rhs.depthBiasClamp )
- , fillModeNonSolid( rhs.fillModeNonSolid )
- , depthBounds( rhs.depthBounds )
- , wideLines( rhs.wideLines )
- , largePoints( rhs.largePoints )
- , alphaToOne( rhs.alphaToOne )
- , multiViewport( rhs.multiViewport )
- , samplerAnisotropy( rhs.samplerAnisotropy )
- , textureCompressionETC2( rhs.textureCompressionETC2 )
- , textureCompressionASTC_LDR( rhs.textureCompressionASTC_LDR )
- , textureCompressionBC( rhs.textureCompressionBC )
- , occlusionQueryPrecise( rhs.occlusionQueryPrecise )
- , pipelineStatisticsQuery( rhs.pipelineStatisticsQuery )
- , vertexPipelineStoresAndAtomics( rhs.vertexPipelineStoresAndAtomics )
- , fragmentStoresAndAtomics( rhs.fragmentStoresAndAtomics )
- , shaderTessellationAndGeometryPointSize( rhs.shaderTessellationAndGeometryPointSize )
- , shaderImageGatherExtended( rhs.shaderImageGatherExtended )
- , shaderStorageImageExtendedFormats( rhs.shaderStorageImageExtendedFormats )
- , shaderStorageImageMultisample( rhs.shaderStorageImageMultisample )
- , shaderStorageImageReadWithoutFormat( rhs.shaderStorageImageReadWithoutFormat )
- , shaderStorageImageWriteWithoutFormat( rhs.shaderStorageImageWriteWithoutFormat )
- , shaderUniformBufferArrayDynamicIndexing( rhs.shaderUniformBufferArrayDynamicIndexing )
- , shaderSampledImageArrayDynamicIndexing( rhs.shaderSampledImageArrayDynamicIndexing )
- , shaderStorageBufferArrayDynamicIndexing( rhs.shaderStorageBufferArrayDynamicIndexing )
- , shaderStorageImageArrayDynamicIndexing( rhs.shaderStorageImageArrayDynamicIndexing )
- , shaderClipDistance( rhs.shaderClipDistance )
- , shaderCullDistance( rhs.shaderCullDistance )
- , shaderFloat64( rhs.shaderFloat64 )
- , shaderInt64( rhs.shaderInt64 )
- , shaderInt16( rhs.shaderInt16 )
- , shaderResourceResidency( rhs.shaderResourceResidency )
- , shaderResourceMinLod( rhs.shaderResourceMinLod )
- , sparseBinding( rhs.sparseBinding )
- , sparseResidencyBuffer( rhs.sparseResidencyBuffer )
- , sparseResidencyImage2D( rhs.sparseResidencyImage2D )
- , sparseResidencyImage3D( rhs.sparseResidencyImage3D )
- , sparseResidency2Samples( rhs.sparseResidency2Samples )
- , sparseResidency4Samples( rhs.sparseResidency4Samples )
- , sparseResidency8Samples( rhs.sparseResidency8Samples )
- , sparseResidency16Samples( rhs.sparseResidency16Samples )
- , sparseResidencyAliased( rhs.sparseResidencyAliased )
- , variableMultisampleRate( rhs.variableMultisampleRate )
- , inheritedQueries( rhs.inheritedQueries )
- {}
-
- PhysicalDeviceFeatures & operator=( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PhysicalDeviceFeatures ) );
- return *this;
- }
-
PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pEnabledFeatures( pEnabledFeatures_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceCreateInfo( DeviceCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , queueCreateInfoCount( rhs.queueCreateInfoCount )
- , pQueueCreateInfos( rhs.pQueueCreateInfos )
- , enabledLayerCount( rhs.enabledLayerCount )
- , ppEnabledLayerNames( rhs.ppEnabledLayerNames )
- , enabledExtensionCount( rhs.enabledExtensionCount )
- , ppEnabledExtensionNames( rhs.ppEnabledExtensionNames )
- , pEnabledFeatures( rhs.pEnabledFeatures )
- {}
-
DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceCreateInfo ) - offsetof( DeviceCreateInfo, pNext ) );
: flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( DeviceDiagnosticsConfigCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- {}
-
DeviceDiagnosticsConfigCreateInfoNV & operator=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceDiagnosticsConfigCreateInfoNV ) - offsetof( DeviceDiagnosticsConfigCreateInfoNV, pNext ) );
: deviceEvent( deviceEvent_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( DeviceEventInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceEvent( rhs.deviceEvent )
- {}
-
DeviceEventInfoEXT & operator=( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceEventInfoEXT ) - offsetof( DeviceEventInfoEXT, pNext ) );
, memoryDeviceIndex( memoryDeviceIndex_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( DeviceGroupBindSparseInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , resourceDeviceIndex( rhs.resourceDeviceIndex )
- , memoryDeviceIndex( rhs.memoryDeviceIndex )
- {}
-
DeviceGroupBindSparseInfo & operator=( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupBindSparseInfo ) - offsetof( DeviceGroupBindSparseInfo, pNext ) );
: deviceMask( deviceMask_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( DeviceGroupCommandBufferBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceMask( rhs.deviceMask )
- {}
-
DeviceGroupCommandBufferBeginInfo & operator=( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupCommandBufferBeginInfo ) - offsetof( DeviceGroupCommandBufferBeginInfo, pNext ) );
, pPhysicalDevices( pPhysicalDevices_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( DeviceGroupDeviceCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , physicalDeviceCount( rhs.physicalDeviceCount )
- , pPhysicalDevices( rhs.pPhysicalDevices )
- {}
-
DeviceGroupDeviceCreateInfo & operator=( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupDeviceCreateInfo ) - offsetof( DeviceGroupDeviceCreateInfo, pNext ) );
{
VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( std::array<uint32_t,VK_MAX_DEVICE_GROUP_SIZE> const& presentMask_ = {},
VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT
- : presentMask{}
+ : presentMask( presentMask_ )
, modes( modes_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,VK_MAX_DEVICE_GROUP_SIZE>::copy( presentMask, presentMask_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , presentMask{}
- , modes( rhs.modes )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,VK_MAX_DEVICE_GROUP_SIZE>::copy( presentMask, rhs.presentMask );
- }
+ {}
DeviceGroupPresentCapabilitiesKHR & operator=( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 )
+ && ( presentMask == rhs.presentMask )
&& ( modes == rhs.modes );
}
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
const void* pNext = {};
- uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, VK_MAX_DEVICE_GROUP_SIZE> presentMask = {};
VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes = {};
};
static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
, mode( mode_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( DeviceGroupPresentInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , swapchainCount( rhs.swapchainCount )
- , pDeviceMasks( rhs.pDeviceMasks )
- , mode( rhs.mode )
- {}
-
DeviceGroupPresentInfoKHR & operator=( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupPresentInfoKHR ) - offsetof( DeviceGroupPresentInfoKHR, pNext ) );
, pDeviceRenderAreas( pDeviceRenderAreas_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( DeviceGroupRenderPassBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceMask( rhs.deviceMask )
- , deviceRenderAreaCount( rhs.deviceRenderAreaCount )
- , pDeviceRenderAreas( rhs.pDeviceRenderAreas )
- {}
-
DeviceGroupRenderPassBeginInfo & operator=( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupRenderPassBeginInfo ) - offsetof( DeviceGroupRenderPassBeginInfo, pNext ) );
, pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( DeviceGroupSubmitInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , waitSemaphoreCount( rhs.waitSemaphoreCount )
- , pWaitSemaphoreDeviceIndices( rhs.pWaitSemaphoreDeviceIndices )
- , commandBufferCount( rhs.commandBufferCount )
- , pCommandBufferDeviceMasks( rhs.pCommandBufferDeviceMasks )
- , signalSemaphoreCount( rhs.signalSemaphoreCount )
- , pSignalSemaphoreDeviceIndices( rhs.pSignalSemaphoreDeviceIndices )
- {}
-
DeviceGroupSubmitInfo & operator=( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupSubmitInfo ) - offsetof( DeviceGroupSubmitInfo, pNext ) );
: modes( modes_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( DeviceGroupSwapchainCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , modes( rhs.modes )
- {}
-
DeviceGroupSwapchainCreateInfoKHR & operator=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupSwapchainCreateInfoKHR ) - offsetof( DeviceGroupSwapchainCreateInfoKHR, pNext ) );
: memory( memory_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( DeviceMemoryOpaqueCaptureAddressInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memory( rhs.memory )
- {}
-
DeviceMemoryOpaqueCaptureAddressInfo & operator=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceMemoryOpaqueCaptureAddressInfo ) - offsetof( DeviceMemoryOpaqueCaptureAddressInfo, pNext ) );
: overallocationBehavior( overallocationBehavior_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , overallocationBehavior( rhs.overallocationBehavior )
- {}
-
DeviceMemoryOverallocationCreateInfoAMD & operator=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) - offsetof( DeviceMemoryOverallocationCreateInfoAMD, pNext ) );
: globalPriority( globalPriority_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , globalPriority( rhs.globalPriority )
- {}
-
DeviceQueueGlobalPriorityCreateInfoEXT & operator=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) - offsetof( DeviceQueueGlobalPriorityCreateInfoEXT, pNext ) );
, queueIndex( queueIndex_ )
{}
- VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( DeviceQueueInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , queueFamilyIndex( rhs.queueFamilyIndex )
- , queueIndex( rhs.queueIndex )
- {}
-
DeviceQueueInfo2 & operator=( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DeviceQueueInfo2 ) - offsetof( DeviceQueueInfo2, pNext ) );
, z( z_ )
{}
- VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( DispatchIndirectCommand const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- , z( rhs.z )
- {}
-
- DispatchIndirectCommand & operator=( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DispatchIndirectCommand ) );
- return *this;
- }
-
DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: displayEvent( displayEvent_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , displayEvent( rhs.displayEvent )
- {}
-
DisplayEventInfoEXT & operator=( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayEventInfoEXT ) - offsetof( DisplayEventInfoEXT, pNext ) );
, refreshRate( refreshRate_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( DisplayModeParametersKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : visibleRegion( rhs.visibleRegion )
- , refreshRate( rhs.refreshRate )
- {}
-
- DisplayModeParametersKHR & operator=( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayModeParametersKHR ) );
- return *this;
- }
-
DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, parameters( parameters_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , parameters( rhs.parameters )
- {}
-
DisplayModeCreateInfoKHR & operator=( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayModeCreateInfoKHR ) - offsetof( DisplayModeCreateInfoKHR, pNext ) );
, parameters( parameters_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModePropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : displayMode( rhs.displayMode )
- , parameters( rhs.parameters )
- {}
-
- DisplayModePropertiesKHR & operator=( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayModePropertiesKHR ) );
- return *this;
- }
-
DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: displayModeProperties( displayModeProperties_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModeProperties2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , displayModeProperties( rhs.displayModeProperties )
- {}
-
DisplayModeProperties2KHR & operator=( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayModeProperties2KHR ) - offsetof( DisplayModeProperties2KHR, pNext ) );
: localDimmingSupport( localDimmingSupport_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , localDimmingSupport( rhs.localDimmingSupport )
- {}
-
DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) - offsetof( DisplayNativeHdrSurfaceCapabilitiesAMD, pNext ) );
, maxDstExtent( maxDstExtent_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneCapabilitiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
- DisplayPlaneCapabilitiesKHR & operator=( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) );
- return *this;
- }
-
DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: capabilities( capabilities_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilities2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , capabilities( rhs.capabilities )
- {}
-
DisplayPlaneCapabilities2KHR & operator=( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneCapabilities2KHR ) - offsetof( DisplayPlaneCapabilities2KHR, pNext ) );
, planeIndex( planeIndex_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayPlaneInfo2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , mode( rhs.mode )
- , planeIndex( rhs.planeIndex )
- {}
-
DisplayPlaneInfo2KHR & operator=( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneInfo2KHR ) - offsetof( DisplayPlaneInfo2KHR, pNext ) );
, currentStackIndex( currentStackIndex_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayPlanePropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : currentDisplay( rhs.currentDisplay )
- , currentStackIndex( rhs.currentStackIndex )
- {}
-
- DisplayPlanePropertiesKHR & operator=( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayPlanePropertiesKHR ) );
- return *this;
- }
-
DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: displayPlaneProperties( displayPlaneProperties_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlaneProperties2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , displayPlaneProperties( rhs.displayPlaneProperties )
- {}
-
DisplayPlaneProperties2KHR & operator=( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneProperties2KHR ) - offsetof( DisplayPlaneProperties2KHR, pNext ) );
: powerState( powerState_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , powerState( rhs.powerState )
- {}
-
DisplayPowerInfoEXT & operator=( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPowerInfoEXT ) - offsetof( DisplayPowerInfoEXT, pNext ) );
, persistent( persistent_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( DisplayPresentInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , srcRect( rhs.srcRect )
- , dstRect( rhs.dstRect )
- , persistent( rhs.persistent )
- {}
-
DisplayPresentInfoKHR & operator=( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPresentInfoKHR ) - offsetof( DisplayPresentInfoKHR, pNext ) );
, persistentContent( persistentContent_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayPropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : display( rhs.display )
- , displayName( rhs.displayName )
- , physicalDimensions( rhs.physicalDimensions )
- , physicalResolution( rhs.physicalResolution )
- , supportedTransforms( rhs.supportedTransforms )
- , planeReorderPossible( rhs.planeReorderPossible )
- , persistentContent( rhs.persistentContent )
- {}
-
- DisplayPropertiesKHR & operator=( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayPropertiesKHR ) );
- return *this;
- }
-
DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: displayProperties( displayProperties_ )
{}
- VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayProperties2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , displayProperties( rhs.displayProperties )
- {}
-
DisplayProperties2KHR & operator=( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplayProperties2KHR ) - offsetof( DisplayProperties2KHR, pNext ) );
, imageExtent( imageExtent_ )
{}
- VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
DisplaySurfaceCreateInfoKHR & operator=( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DisplaySurfaceCreateInfoKHR ) - offsetof( DisplaySurfaceCreateInfoKHR, pNext ) );
, firstInstance( firstInstance_ )
{}
- VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( DrawIndexedIndirectCommand const& rhs ) VULKAN_HPP_NOEXCEPT
- : indexCount( rhs.indexCount )
- , instanceCount( rhs.instanceCount )
- , firstIndex( rhs.firstIndex )
- , vertexOffset( rhs.vertexOffset )
- , firstInstance( rhs.firstInstance )
- {}
-
- DrawIndexedIndirectCommand & operator=( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DrawIndexedIndirectCommand ) );
- return *this;
- }
-
DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, firstInstance( firstInstance_ )
{}
- VULKAN_HPP_CONSTEXPR DrawIndirectCommand( DrawIndirectCommand const& rhs ) VULKAN_HPP_NOEXCEPT
- : vertexCount( rhs.vertexCount )
- , instanceCount( rhs.instanceCount )
- , firstVertex( rhs.firstVertex )
- , firstInstance( rhs.firstInstance )
- {}
-
- DrawIndirectCommand & operator=( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DrawIndirectCommand ) );
- return *this;
- }
-
DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, firstTask( firstTask_ )
{}
- VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( DrawMeshTasksIndirectCommandNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : taskCount( rhs.taskCount )
- , firstTask( rhs.firstTask )
- {}
-
- DrawMeshTasksIndirectCommandNV & operator=( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
- return *this;
- }
-
DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, drmFormatModifierTilingFeatures( drmFormatModifierTilingFeatures_ )
{}
- VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( DrmFormatModifierPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : drmFormatModifier( rhs.drmFormatModifier )
- , drmFormatModifierPlaneCount( rhs.drmFormatModifierPlaneCount )
- , drmFormatModifierTilingFeatures( rhs.drmFormatModifierTilingFeatures )
- {}
-
- DrmFormatModifierPropertiesEXT & operator=( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( DrmFormatModifierPropertiesEXT ) );
- return *this;
- }
-
DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
{}
- VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( DrmFormatModifierPropertiesListEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , drmFormatModifierCount( rhs.drmFormatModifierCount )
- , pDrmFormatModifierProperties( rhs.pDrmFormatModifierProperties )
- {}
-
DrmFormatModifierPropertiesListEXT & operator=( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( DrmFormatModifierPropertiesListEXT ) - offsetof( DrmFormatModifierPropertiesListEXT, pNext ) );
: flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR EventCreateInfo( EventCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- {}
-
EventCreateInfo & operator=( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( EventCreateInfo ) - offsetof( EventCreateInfo, pNext ) );
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( ExportFenceCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExportFenceCreateInfo & operator=( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportFenceCreateInfo ) - offsetof( ExportFenceCreateInfo, pNext ) );
, name( name_ )
{}
- VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( ExportFenceWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pAttributes( rhs.pAttributes )
- , dwAccess( rhs.dwAccess )
- , name( rhs.name )
- {}
-
ExportFenceWin32HandleInfoKHR & operator=( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportFenceWin32HandleInfoKHR ) - offsetof( ExportFenceWin32HandleInfoKHR, pNext ) );
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( ExportMemoryAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExportMemoryAllocateInfo & operator=( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportMemoryAllocateInfo ) - offsetof( ExportMemoryAllocateInfo, pNext ) );
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( ExportMemoryAllocateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExportMemoryAllocateInfoNV & operator=( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportMemoryAllocateInfoNV ) - offsetof( ExportMemoryAllocateInfoNV, pNext ) );
, name( name_ )
{}
- VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( ExportMemoryWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pAttributes( rhs.pAttributes )
- , dwAccess( rhs.dwAccess )
- , name( rhs.name )
- {}
-
ExportMemoryWin32HandleInfoKHR & operator=( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportMemoryWin32HandleInfoKHR ) - offsetof( ExportMemoryWin32HandleInfoKHR, pNext ) );
, dwAccess( dwAccess_ )
{}
- VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( ExportMemoryWin32HandleInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pAttributes( rhs.pAttributes )
- , dwAccess( rhs.dwAccess )
- {}
-
ExportMemoryWin32HandleInfoNV & operator=( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportMemoryWin32HandleInfoNV ) - offsetof( ExportMemoryWin32HandleInfoNV, pNext ) );
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( ExportSemaphoreCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExportSemaphoreCreateInfo & operator=( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportSemaphoreCreateInfo ) - offsetof( ExportSemaphoreCreateInfo, pNext ) );
, name( name_ )
{}
- VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( ExportSemaphoreWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pAttributes( rhs.pAttributes )
- , dwAccess( rhs.dwAccess )
- , name( rhs.name )
- {}
-
ExportSemaphoreWin32HandleInfoKHR & operator=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExportSemaphoreWin32HandleInfoKHR ) - offsetof( ExportSemaphoreWin32HandleInfoKHR, pNext ) );
{
VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& extensionName_ = {},
uint32_t specVersion_ = {} ) VULKAN_HPP_NOEXCEPT
- : extensionName{}
+ : extensionName( extensionName_ )
, specVersion( specVersion_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( extensionName, extensionName_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( ExtensionProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : extensionName{}
- , specVersion( rhs.specVersion )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( extensionName, rhs.extensionName );
- }
-
- ExtensionProperties & operator=( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ExtensionProperties ) );
- return *this;
- }
+ {}
ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
#else
bool operator==( ExtensionProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
+ return ( extensionName == rhs.extensionName )
&& ( specVersion == rhs.specVersion );
}
#endif
public:
- char extensionName[VK_MAX_EXTENSION_NAME_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> extensionName = {};
uint32_t specVersion = {};
};
static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
, compatibleHandleTypes( compatibleHandleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( ExternalMemoryProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : externalMemoryFeatures( rhs.externalMemoryFeatures )
- , exportFromImportedHandleTypes( rhs.exportFromImportedHandleTypes )
- , compatibleHandleTypes( rhs.compatibleHandleTypes )
- {}
-
- ExternalMemoryProperties & operator=( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ExternalMemoryProperties ) );
- return *this;
- }
-
ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: externalMemoryProperties( externalMemoryProperties_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalBufferProperties( ExternalBufferProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , externalMemoryProperties( rhs.externalMemoryProperties )
- {}
-
ExternalBufferProperties & operator=( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalBufferProperties ) - offsetof( ExternalBufferProperties, pNext ) );
, externalFenceFeatures( externalFenceFeatures_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalFenceProperties( ExternalFenceProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , exportFromImportedHandleTypes( rhs.exportFromImportedHandleTypes )
- , compatibleHandleTypes( rhs.compatibleHandleTypes )
- , externalFenceFeatures( rhs.externalFenceFeatures )
- {}
-
ExternalFenceProperties & operator=( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalFenceProperties ) - offsetof( ExternalFenceProperties, pNext ) );
: externalFormat( externalFormat_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( ExternalFormatANDROID const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , externalFormat( rhs.externalFormat )
- {}
-
ExternalFormatANDROID & operator=( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalFormatANDROID ) - offsetof( ExternalFormatANDROID, pNext ) );
: externalMemoryProperties( externalMemoryProperties_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( ExternalImageFormatProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , externalMemoryProperties( rhs.externalMemoryProperties )
- {}
-
ExternalImageFormatProperties & operator=( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalImageFormatProperties ) - offsetof( ExternalImageFormatProperties, pNext ) );
, maxResourceSize( maxResourceSize_ )
{}
- VULKAN_HPP_CONSTEXPR ImageFormatProperties( ImageFormatProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : maxExtent( rhs.maxExtent )
- , maxMipLevels( rhs.maxMipLevels )
- , maxArrayLayers( rhs.maxArrayLayers )
- , sampleCounts( rhs.sampleCounts )
- , maxResourceSize( rhs.maxResourceSize )
- {}
-
- ImageFormatProperties & operator=( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageFormatProperties ) );
- return *this;
- }
-
ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, compatibleHandleTypes( compatibleHandleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( ExternalImageFormatPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : imageFormatProperties( rhs.imageFormatProperties )
- , externalMemoryFeatures( rhs.externalMemoryFeatures )
- , exportFromImportedHandleTypes( rhs.exportFromImportedHandleTypes )
- , compatibleHandleTypes( rhs.compatibleHandleTypes )
- {}
-
- ExternalImageFormatPropertiesNV & operator=( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ExternalImageFormatPropertiesNV ) );
- return *this;
- }
-
ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( ExternalMemoryBufferCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExternalMemoryBufferCreateInfo & operator=( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalMemoryBufferCreateInfo ) - offsetof( ExternalMemoryBufferCreateInfo, pNext ) );
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( ExternalMemoryImageCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExternalMemoryImageCreateInfo & operator=( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalMemoryImageCreateInfo ) - offsetof( ExternalMemoryImageCreateInfo, pNext ) );
: handleTypes( handleTypes_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( ExternalMemoryImageCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleTypes( rhs.handleTypes )
- {}
-
ExternalMemoryImageCreateInfoNV & operator=( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalMemoryImageCreateInfoNV ) - offsetof( ExternalMemoryImageCreateInfoNV, pNext ) );
, externalSemaphoreFeatures( externalSemaphoreFeatures_ )
{}
- VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( ExternalSemaphoreProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , exportFromImportedHandleTypes( rhs.exportFromImportedHandleTypes )
- , compatibleHandleTypes( rhs.compatibleHandleTypes )
- , externalSemaphoreFeatures( rhs.externalSemaphoreFeatures )
- {}
-
ExternalSemaphoreProperties & operator=( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ExternalSemaphoreProperties ) - offsetof( ExternalSemaphoreProperties, pNext ) );
: flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR FenceCreateInfo( FenceCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- {}
-
FenceCreateInfo & operator=( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FenceCreateInfo ) - offsetof( FenceCreateInfo, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( FenceGetFdInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fence( rhs.fence )
- , handleType( rhs.handleType )
- {}
-
FenceGetFdInfoKHR & operator=( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FenceGetFdInfoKHR ) - offsetof( FenceGetFdInfoKHR, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( FenceGetWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fence( rhs.fence )
- , handleType( rhs.handleType )
- {}
-
FenceGetWin32HandleInfoKHR & operator=( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FenceGetWin32HandleInfoKHR ) - offsetof( FenceGetWin32HandleInfoKHR, pNext ) );
, filterCubicMinmax( filterCubicMinmax_ )
{}
- VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( FilterCubicImageViewImageFormatPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , filterCubic( rhs.filterCubic )
- , filterCubicMinmax( rhs.filterCubicMinmax )
- {}
-
FilterCubicImageViewImageFormatPropertiesEXT & operator=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) - offsetof( FilterCubicImageViewImageFormatPropertiesEXT, pNext ) );
, bufferFeatures( bufferFeatures_ )
{}
- VULKAN_HPP_CONSTEXPR FormatProperties( FormatProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : linearTilingFeatures( rhs.linearTilingFeatures )
- , optimalTilingFeatures( rhs.optimalTilingFeatures )
- , bufferFeatures( rhs.bufferFeatures )
- {}
-
- FormatProperties & operator=( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( FormatProperties ) );
- return *this;
- }
-
FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: formatProperties( formatProperties_ )
{}
- VULKAN_HPP_CONSTEXPR FormatProperties2( FormatProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , formatProperties( rhs.formatProperties )
- {}
-
FormatProperties2 & operator=( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FormatProperties2 ) - offsetof( FormatProperties2, pNext ) );
, pViewFormats( pViewFormats_ )
{}
- VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( FramebufferAttachmentImageInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , usage( rhs.usage )
- , width( rhs.width )
- , height( rhs.height )
- , layerCount( rhs.layerCount )
- , viewFormatCount( rhs.viewFormatCount )
- , pViewFormats( rhs.pViewFormats )
- {}
-
FramebufferAttachmentImageInfo & operator=( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FramebufferAttachmentImageInfo ) - offsetof( FramebufferAttachmentImageInfo, pNext ) );
, pAttachmentImageInfos( pAttachmentImageInfos_ )
{}
- VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( FramebufferAttachmentsCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , attachmentImageInfoCount( rhs.attachmentImageInfoCount )
- , pAttachmentImageInfos( rhs.pAttachmentImageInfos )
- {}
-
FramebufferAttachmentsCreateInfo & operator=( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FramebufferAttachmentsCreateInfo ) - offsetof( FramebufferAttachmentsCreateInfo, pNext ) );
, layers( layers_ )
{}
- VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( FramebufferCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , renderPass( rhs.renderPass )
- , attachmentCount( rhs.attachmentCount )
- , pAttachments( rhs.pAttachments )
- , width( rhs.width )
- , height( rhs.height )
- , layers( rhs.layers )
- {}
-
FramebufferCreateInfo & operator=( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FramebufferCreateInfo ) - offsetof( FramebufferCreateInfo, pNext ) );
, colorSamples( colorSamples_ )
{}
- VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( FramebufferMixedSamplesCombinationNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , coverageReductionMode( rhs.coverageReductionMode )
- , rasterizationSamples( rhs.rasterizationSamples )
- , depthStencilSamples( rhs.depthStencilSamples )
- , colorSamples( rhs.colorSamples )
- {}
-
FramebufferMixedSamplesCombinationNV & operator=( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( FramebufferMixedSamplesCombinationNV ) - offsetof( FramebufferMixedSamplesCombinationNV, pNext ) );
, offset( offset_ )
{}
- VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( IndirectCommandsStreamNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : buffer( rhs.buffer )
- , offset( rhs.offset )
- {}
-
- IndirectCommandsStreamNV & operator=( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( IndirectCommandsStreamNV ) );
- return *this;
- }
-
IndirectCommandsStreamNV( VkIndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, sequencesIndexOffset( sequencesIndexOffset_ )
{}
- VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( GeneratedCommandsInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pipelineBindPoint( rhs.pipelineBindPoint )
- , pipeline( rhs.pipeline )
- , indirectCommandsLayout( rhs.indirectCommandsLayout )
- , streamCount( rhs.streamCount )
- , pStreams( rhs.pStreams )
- , sequencesCount( rhs.sequencesCount )
- , preprocessBuffer( rhs.preprocessBuffer )
- , preprocessOffset( rhs.preprocessOffset )
- , preprocessSize( rhs.preprocessSize )
- , sequencesCountBuffer( rhs.sequencesCountBuffer )
- , sequencesCountOffset( rhs.sequencesCountOffset )
- , sequencesIndexBuffer( rhs.sequencesIndexBuffer )
- , sequencesIndexOffset( rhs.sequencesIndexOffset )
- {}
-
GeneratedCommandsInfoNV & operator=( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GeneratedCommandsInfoNV ) - offsetof( GeneratedCommandsInfoNV, pNext ) );
, maxSequencesCount( maxSequencesCount_ )
{}
- VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( GeneratedCommandsMemoryRequirementsInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pipelineBindPoint( rhs.pipelineBindPoint )
- , pipeline( rhs.pipeline )
- , indirectCommandsLayout( rhs.indirectCommandsLayout )
- , maxSequencesCount( rhs.maxSequencesCount )
- {}
-
GeneratedCommandsMemoryRequirementsInfoNV & operator=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GeneratedCommandsMemoryRequirementsInfoNV ) - offsetof( GeneratedCommandsMemoryRequirementsInfoNV, pNext ) );
return *this;
}
+ GeneratedCommandsMemoryRequirementsInfoNV & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ GeneratedCommandsMemoryRequirementsInfoNV & setPipelineBindPoint( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pipelineBindPoint = pipelineBindPoint_;
+ return *this;
+ }
+
+ GeneratedCommandsMemoryRequirementsInfoNV & setPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pipeline = pipeline_;
+ return *this;
+ }
+
+ GeneratedCommandsMemoryRequirementsInfoNV & setIndirectCommandsLayout( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout_ ) VULKAN_HPP_NOEXCEPT
+ {
+ indirectCommandsLayout = indirectCommandsLayout_;
+ return *this;
+ }
+
+ GeneratedCommandsMemoryRequirementsInfoNV & setMaxSequencesCount( uint32_t maxSequencesCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ maxSequencesCount = maxSequencesCount_;
+ return *this;
+ }
+
operator VkGeneratedCommandsMemoryRequirementsInfoNV const&() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>( this );
, inputRate( inputRate_ )
{}
- VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( VertexInputBindingDescription const& rhs ) VULKAN_HPP_NOEXCEPT
- : binding( rhs.binding )
- , stride( rhs.stride )
- , inputRate( rhs.inputRate )
- {}
-
- VertexInputBindingDescription & operator=( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( VertexInputBindingDescription ) );
- return *this;
- }
-
VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, offset( offset_ )
{}
- VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( VertexInputAttributeDescription const& rhs ) VULKAN_HPP_NOEXCEPT
- : location( rhs.location )
- , binding( rhs.binding )
- , format( rhs.format )
- , offset( rhs.offset )
- {}
-
- VertexInputAttributeDescription & operator=( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( VertexInputAttributeDescription ) );
- return *this;
- }
-
VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , vertexBindingDescriptionCount( rhs.vertexBindingDescriptionCount )
- , pVertexBindingDescriptions( rhs.pVertexBindingDescriptions )
- , vertexAttributeDescriptionCount( rhs.vertexAttributeDescriptionCount )
- , pVertexAttributeDescriptions( rhs.pVertexAttributeDescriptions )
- {}
-
PipelineVertexInputStateCreateInfo & operator=( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineVertexInputStateCreateInfo ) - offsetof( PipelineVertexInputStateCreateInfo, pNext ) );
, primitiveRestartEnable( primitiveRestartEnable_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , topology( rhs.topology )
- , primitiveRestartEnable( rhs.primitiveRestartEnable )
- {}
-
PipelineInputAssemblyStateCreateInfo & operator=( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineInputAssemblyStateCreateInfo ) - offsetof( PipelineInputAssemblyStateCreateInfo, pNext ) );
, patchControlPoints( patchControlPoints_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , patchControlPoints( rhs.patchControlPoints )
- {}
-
PipelineTessellationStateCreateInfo & operator=( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineTessellationStateCreateInfo ) - offsetof( PipelineTessellationStateCreateInfo, pNext ) );
, maxDepth( maxDepth_ )
{}
- VULKAN_HPP_CONSTEXPR Viewport( Viewport const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- , width( rhs.width )
- , height( rhs.height )
- , minDepth( rhs.minDepth )
- , maxDepth( rhs.maxDepth )
- {}
-
- Viewport & operator=( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( Viewport ) );
- return *this;
- }
-
Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pScissors( pScissors_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , viewportCount( rhs.viewportCount )
- , pViewports( rhs.pViewports )
- , scissorCount( rhs.scissorCount )
- , pScissors( rhs.pScissors )
- {}
-
PipelineViewportStateCreateInfo & operator=( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportStateCreateInfo ) - offsetof( PipelineViewportStateCreateInfo, pNext ) );
, lineWidth( lineWidth_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , depthClampEnable( rhs.depthClampEnable )
- , rasterizerDiscardEnable( rhs.rasterizerDiscardEnable )
- , polygonMode( rhs.polygonMode )
- , cullMode( rhs.cullMode )
- , frontFace( rhs.frontFace )
- , depthBiasEnable( rhs.depthBiasEnable )
- , depthBiasConstantFactor( rhs.depthBiasConstantFactor )
- , depthBiasClamp( rhs.depthBiasClamp )
- , depthBiasSlopeFactor( rhs.depthBiasSlopeFactor )
- , lineWidth( rhs.lineWidth )
- {}
-
PipelineRasterizationStateCreateInfo & operator=( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationStateCreateInfo ) - offsetof( PipelineRasterizationStateCreateInfo, pNext ) );
, alphaToOneEnable( alphaToOneEnable_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , rasterizationSamples( rhs.rasterizationSamples )
- , sampleShadingEnable( rhs.sampleShadingEnable )
- , minSampleShading( rhs.minSampleShading )
- , pSampleMask( rhs.pSampleMask )
- , alphaToCoverageEnable( rhs.alphaToCoverageEnable )
- , alphaToOneEnable( rhs.alphaToOneEnable )
- {}
-
PipelineMultisampleStateCreateInfo & operator=( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineMultisampleStateCreateInfo ) - offsetof( PipelineMultisampleStateCreateInfo, pNext ) );
, reference( reference_ )
{}
- VULKAN_HPP_CONSTEXPR StencilOpState( StencilOpState const& rhs ) VULKAN_HPP_NOEXCEPT
- : failOp( rhs.failOp )
- , passOp( rhs.passOp )
- , depthFailOp( rhs.depthFailOp )
- , compareOp( rhs.compareOp )
- , compareMask( rhs.compareMask )
- , writeMask( rhs.writeMask )
- , reference( rhs.reference )
- {}
-
- StencilOpState & operator=( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( StencilOpState ) );
- return *this;
- }
-
StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, maxDepthBounds( maxDepthBounds_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , depthTestEnable( rhs.depthTestEnable )
- , depthWriteEnable( rhs.depthWriteEnable )
- , depthCompareOp( rhs.depthCompareOp )
- , depthBoundsTestEnable( rhs.depthBoundsTestEnable )
- , stencilTestEnable( rhs.stencilTestEnable )
- , front( rhs.front )
- , back( rhs.back )
- , minDepthBounds( rhs.minDepthBounds )
- , maxDepthBounds( rhs.maxDepthBounds )
- {}
-
PipelineDepthStencilStateCreateInfo & operator=( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineDepthStencilStateCreateInfo ) - offsetof( PipelineDepthStencilStateCreateInfo, pNext ) );
, colorWriteMask( colorWriteMask_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( PipelineColorBlendAttachmentState const& rhs ) VULKAN_HPP_NOEXCEPT
- : blendEnable( rhs.blendEnable )
- , srcColorBlendFactor( rhs.srcColorBlendFactor )
- , dstColorBlendFactor( rhs.dstColorBlendFactor )
- , colorBlendOp( rhs.colorBlendOp )
- , srcAlphaBlendFactor( rhs.srcAlphaBlendFactor )
- , dstAlphaBlendFactor( rhs.dstAlphaBlendFactor )
- , alphaBlendOp( rhs.alphaBlendOp )
- , colorWriteMask( rhs.colorWriteMask )
- {}
-
- PipelineColorBlendAttachmentState & operator=( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PipelineColorBlendAttachmentState ) );
- return *this;
- }
-
PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, logicOp( logicOp_ )
, attachmentCount( attachmentCount_ )
, pAttachments( pAttachments_ )
- , blendConstants{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( blendConstants, blendConstants_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , logicOpEnable( rhs.logicOpEnable )
- , logicOp( rhs.logicOp )
- , attachmentCount( rhs.attachmentCount )
- , pAttachments( rhs.pAttachments )
- , blendConstants{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( blendConstants, rhs.blendConstants );
- }
+ , blendConstants( blendConstants_ )
+ {}
PipelineColorBlendStateCreateInfo & operator=( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
PipelineColorBlendStateCreateInfo & setBlendConstants( std::array<float,4> blendConstants_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
+ blendConstants = blendConstants_;
return *this;
}
&& ( logicOp == rhs.logicOp )
&& ( attachmentCount == rhs.attachmentCount )
&& ( pAttachments == rhs.pAttachments )
- && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
+ && ( blendConstants == rhs.blendConstants );
}
bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::LogicOp logicOp = VULKAN_HPP_NAMESPACE::LogicOp::eClear;
uint32_t attachmentCount = {};
const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState* pAttachments = {};
- float blendConstants[4] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> blendConstants = {};
};
static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PipelineColorBlendStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
, pDynamicStates( pDynamicStates_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , dynamicStateCount( rhs.dynamicStateCount )
- , pDynamicStates( rhs.pDynamicStates )
- {}
-
PipelineDynamicStateCreateInfo & operator=( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineDynamicStateCreateInfo ) - offsetof( PipelineDynamicStateCreateInfo, pNext ) );
, basePipelineIndex( basePipelineIndex_ )
{}
- VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( GraphicsPipelineCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
GraphicsPipelineCreateInfo & operator=( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GraphicsPipelineCreateInfo ) - offsetof( GraphicsPipelineCreateInfo, pNext ) );
, pTessellationState( pTessellationState_ )
{}
- VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( GraphicsShaderGroupCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , stageCount( rhs.stageCount )
- , pStages( rhs.pStages )
- , pVertexInputState( rhs.pVertexInputState )
- , pTessellationState( rhs.pTessellationState )
- {}
-
GraphicsShaderGroupCreateInfoNV & operator=( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GraphicsShaderGroupCreateInfoNV ) - offsetof( GraphicsShaderGroupCreateInfoNV, pNext ) );
, pPipelines( pPipelines_ )
{}
- VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( GraphicsPipelineShaderGroupsCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , groupCount( rhs.groupCount )
- , pGroups( rhs.pGroups )
- , pipelineCount( rhs.pipelineCount )
- , pPipelines( rhs.pPipelines )
- {}
-
GraphicsPipelineShaderGroupsCreateInfoNV & operator=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( GraphicsPipelineShaderGroupsCreateInfoNV ) - offsetof( GraphicsPipelineShaderGroupsCreateInfoNV, pNext ) );
, y( y_ )
{}
- VULKAN_HPP_CONSTEXPR XYColorEXT( XYColorEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- {}
-
- XYColorEXT & operator=( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( XYColorEXT ) );
- return *this;
- }
-
XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
{}
- VULKAN_HPP_CONSTEXPR HdrMetadataEXT( HdrMetadataEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , displayPrimaryRed( rhs.displayPrimaryRed )
- , displayPrimaryGreen( rhs.displayPrimaryGreen )
- , displayPrimaryBlue( rhs.displayPrimaryBlue )
- , whitePoint( rhs.whitePoint )
- , maxLuminance( rhs.maxLuminance )
- , minLuminance( rhs.minLuminance )
- , maxContentLightLevel( rhs.maxContentLightLevel )
- , maxFrameAverageLightLevel( rhs.maxFrameAverageLightLevel )
- {}
-
HdrMetadataEXT & operator=( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( HdrMetadataEXT ) - offsetof( HdrMetadataEXT, pNext ) );
: flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- {}
-
HeadlessSurfaceCreateInfoEXT & operator=( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( HeadlessSurfaceCreateInfoEXT ) - offsetof( HeadlessSurfaceCreateInfoEXT, pNext ) );
, pView( pView_ )
{}
- VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( IOSSurfaceCreateInfoMVK const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pView( rhs.pView )
- {}
-
IOSSurfaceCreateInfoMVK & operator=( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( IOSSurfaceCreateInfoMVK ) - offsetof( IOSSurfaceCreateInfoMVK, pNext ) );
VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {},
std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const& dstOffsets_ = {} ) VULKAN_HPP_NOEXCEPT
: srcSubresource( srcSubresource_ )
- , srcOffsets{}
+ , srcOffsets( srcOffsets_ )
, dstSubresource( dstSubresource_ )
- , dstOffsets{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::Offset3D,2>::copy( srcOffsets, srcOffsets_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::Offset3D,2>::copy( dstOffsets, dstOffsets_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 ImageBlit( ImageBlit const& rhs ) VULKAN_HPP_NOEXCEPT
- : srcSubresource( rhs.srcSubresource )
- , srcOffsets{}
- , dstSubresource( rhs.dstSubresource )
- , dstOffsets{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::Offset3D,2>::copy( srcOffsets, rhs.srcOffsets );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::Offset3D,2>::copy( dstOffsets, rhs.dstOffsets );
- }
-
- ImageBlit & operator=( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageBlit ) );
- return *this;
- }
+ , dstOffsets( dstOffsets_ )
+ {}
ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
{
ImageBlit & setSrcOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> srcOffsets_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( srcOffsets, srcOffsets_.data(), 2 * sizeof( VULKAN_HPP_NAMESPACE::Offset3D ) );
+ srcOffsets = srcOffsets_;
return *this;
}
ImageBlit & setDstOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> dstOffsets_ ) VULKAN_HPP_NOEXCEPT
{
- memcpy( dstOffsets, dstOffsets_.data(), 2 * sizeof( VULKAN_HPP_NAMESPACE::Offset3D ) );
+ dstOffsets = dstOffsets_;
return *this;
}
bool operator==( ImageBlit const& rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( srcSubresource == rhs.srcSubresource )
- && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( VULKAN_HPP_NAMESPACE::Offset3D ) ) == 0 )
+ && ( srcOffsets == rhs.srcOffsets )
&& ( dstSubresource == rhs.dstSubresource )
- && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( VULKAN_HPP_NAMESPACE::Offset3D ) ) == 0 );
+ && ( dstOffsets == rhs.dstOffsets );
}
bool operator!=( ImageBlit const& rhs ) const VULKAN_HPP_NOEXCEPT
public:
VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {};
- VULKAN_HPP_NAMESPACE::Offset3D srcOffsets[2] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> srcOffsets = {};
VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {};
- VULKAN_HPP_NAMESPACE::Offset3D dstOffsets[2] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> dstOffsets = {};
};
static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ImageBlit>::value, "struct wrapper is not a standard layout!" );
, extent( extent_ )
{}
- VULKAN_HPP_CONSTEXPR ImageCopy( ImageCopy const& rhs ) VULKAN_HPP_NOEXCEPT
- : srcSubresource( rhs.srcSubresource )
- , srcOffset( rhs.srcOffset )
- , dstSubresource( rhs.dstSubresource )
- , dstOffset( rhs.dstOffset )
- , extent( rhs.extent )
- {}
-
- ImageCopy & operator=( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageCopy ) );
- return *this;
- }
-
ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, initialLayout( initialLayout_ )
{}
- VULKAN_HPP_CONSTEXPR ImageCreateInfo( ImageCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
ImageCreateInfo & operator=( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageCreateInfo ) - offsetof( ImageCreateInfo, pNext ) );
, depthPitch( depthPitch_ )
{}
- VULKAN_HPP_CONSTEXPR SubresourceLayout( SubresourceLayout const& rhs ) VULKAN_HPP_NOEXCEPT
- : offset( rhs.offset )
- , size( rhs.size )
- , rowPitch( rhs.rowPitch )
- , arrayPitch( rhs.arrayPitch )
- , depthPitch( rhs.depthPitch )
- {}
-
- SubresourceLayout & operator=( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SubresourceLayout ) );
- return *this;
- }
-
SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pPlaneLayouts( pPlaneLayouts_ )
{}
- VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , drmFormatModifier( rhs.drmFormatModifier )
- , drmFormatModifierPlaneCount( rhs.drmFormatModifierPlaneCount )
- , pPlaneLayouts( rhs.pPlaneLayouts )
- {}
-
ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) - offsetof( ImageDrmFormatModifierExplicitCreateInfoEXT, pNext ) );
, pDrmFormatModifiers( pDrmFormatModifiers_ )
{}
- VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , drmFormatModifierCount( rhs.drmFormatModifierCount )
- , pDrmFormatModifiers( rhs.pDrmFormatModifiers )
- {}
-
ImageDrmFormatModifierListCreateInfoEXT & operator=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) - offsetof( ImageDrmFormatModifierListCreateInfoEXT, pNext ) );
: drmFormatModifier( drmFormatModifier_ )
{}
- VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( ImageDrmFormatModifierPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , drmFormatModifier( rhs.drmFormatModifier )
- {}
-
ImageDrmFormatModifierPropertiesEXT & operator=( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageDrmFormatModifierPropertiesEXT ) - offsetof( ImageDrmFormatModifierPropertiesEXT, pNext ) );
, pViewFormats( pViewFormats_ )
{}
- VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( ImageFormatListCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , viewFormatCount( rhs.viewFormatCount )
- , pViewFormats( rhs.pViewFormats )
- {}
-
ImageFormatListCreateInfo & operator=( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageFormatListCreateInfo ) - offsetof( ImageFormatListCreateInfo, pNext ) );
: imageFormatProperties( imageFormatProperties_ )
{}
- VULKAN_HPP_CONSTEXPR ImageFormatProperties2( ImageFormatProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , imageFormatProperties( rhs.imageFormatProperties )
- {}
-
ImageFormatProperties2 & operator=( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageFormatProperties2 ) - offsetof( ImageFormatProperties2, pNext ) );
, layerCount( layerCount_ )
{}
- VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageSubresourceRange const& rhs ) VULKAN_HPP_NOEXCEPT
- : aspectMask( rhs.aspectMask )
- , baseMipLevel( rhs.baseMipLevel )
- , levelCount( rhs.levelCount )
- , baseArrayLayer( rhs.baseArrayLayer )
- , layerCount( rhs.layerCount )
- {}
-
- ImageSubresourceRange & operator=( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageSubresourceRange ) );
- return *this;
- }
-
ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, subresourceRange( subresourceRange_ )
{}
- VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( ImageMemoryBarrier const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
ImageMemoryBarrier & operator=( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageMemoryBarrier ) - offsetof( ImageMemoryBarrier, pNext ) );
: image( image_ )
{}
- VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( ImageMemoryRequirementsInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , image( rhs.image )
- {}
-
ImageMemoryRequirementsInfo2 & operator=( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageMemoryRequirementsInfo2 ) - offsetof( ImageMemoryRequirementsInfo2, pNext ) );
, imagePipeHandle( imagePipeHandle_ )
{}
- VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , imagePipeHandle( rhs.imagePipeHandle )
- {}
-
ImagePipeSurfaceCreateInfoFUCHSIA & operator=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) - offsetof( ImagePipeSurfaceCreateInfoFUCHSIA, pNext ) );
: planeAspect( planeAspect_ )
{}
- VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( ImagePlaneMemoryRequirementsInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , planeAspect( rhs.planeAspect )
- {}
-
ImagePlaneMemoryRequirementsInfo & operator=( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImagePlaneMemoryRequirementsInfo ) - offsetof( ImagePlaneMemoryRequirementsInfo, pNext ) );
, extent( extent_ )
{}
- VULKAN_HPP_CONSTEXPR ImageResolve( ImageResolve const& rhs ) VULKAN_HPP_NOEXCEPT
- : srcSubresource( rhs.srcSubresource )
- , srcOffset( rhs.srcOffset )
- , dstSubresource( rhs.dstSubresource )
- , dstOffset( rhs.dstOffset )
- , extent( rhs.extent )
- {}
-
- ImageResolve & operator=( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ImageResolve ) );
- return *this;
- }
-
ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: image( image_ )
{}
- VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( ImageSparseMemoryRequirementsInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , image( rhs.image )
- {}
-
ImageSparseMemoryRequirementsInfo2 & operator=( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageSparseMemoryRequirementsInfo2 ) - offsetof( ImageSparseMemoryRequirementsInfo2, pNext ) );
: stencilUsage( stencilUsage_ )
{}
- VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( ImageStencilUsageCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , stencilUsage( rhs.stencilUsage )
- {}
-
ImageStencilUsageCreateInfo & operator=( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageStencilUsageCreateInfo ) - offsetof( ImageStencilUsageCreateInfo, pNext ) );
: swapchain( swapchain_ )
{}
- VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( ImageSwapchainCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , swapchain( rhs.swapchain )
- {}
-
ImageSwapchainCreateInfoKHR & operator=( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageSwapchainCreateInfoKHR ) - offsetof( ImageSwapchainCreateInfoKHR, pNext ) );
: decodeMode( decodeMode_ )
{}
- VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( ImageViewASTCDecodeModeEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , decodeMode( rhs.decodeMode )
- {}
-
ImageViewASTCDecodeModeEXT & operator=( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageViewASTCDecodeModeEXT ) - offsetof( ImageViewASTCDecodeModeEXT, pNext ) );
static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ImageViewASTCDecodeModeEXT>::value, "struct wrapper is not a standard layout!" );
+ struct ImageViewAddressPropertiesNVX
+ {
+ VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {},
+ VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
+ : deviceAddress( deviceAddress_ )
+ , size( size_ )
+ {}
+
+ ImageViewAddressPropertiesNVX & operator=( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ memcpy( &pNext, &rhs.pNext, sizeof( ImageViewAddressPropertiesNVX ) - offsetof( ImageViewAddressPropertiesNVX, pNext ) );
+ return *this;
+ }
+
+ ImageViewAddressPropertiesNVX( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = rhs;
+ }
+
+ ImageViewAddressPropertiesNVX& operator=( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const *>(&rhs);
+ return *this;
+ }
+
+ operator VkImageViewAddressPropertiesNVX const&() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkImageViewAddressPropertiesNVX*>( this );
+ }
+
+ operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkImageViewAddressPropertiesNVX*>( this );
+ }
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+ auto operator<=>( ImageViewAddressPropertiesNVX const& ) const = default;
+#else
+ bool operator==( ImageViewAddressPropertiesNVX const& rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( deviceAddress == rhs.deviceAddress )
+ && ( size == rhs.size );
+ }
+
+ bool operator!=( ImageViewAddressPropertiesNVX const& rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewAddressPropertiesNVX;
+ void* pNext = {};
+ VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {};
+ VULKAN_HPP_NAMESPACE::DeviceSize size = {};
+ };
+ static_assert( sizeof( ImageViewAddressPropertiesNVX ) == sizeof( VkImageViewAddressPropertiesNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageViewAddressPropertiesNVX>::value, "struct wrapper is not a standard layout!" );
+
struct ImageViewCreateInfo
{
VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags flags_ = {},
, subresourceRange( subresourceRange_ )
{}
- VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( ImageViewCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , image( rhs.image )
- , viewType( rhs.viewType )
- , format( rhs.format )
- , components( rhs.components )
- , subresourceRange( rhs.subresourceRange )
- {}
-
ImageViewCreateInfo & operator=( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageViewCreateInfo ) - offsetof( ImageViewCreateInfo, pNext ) );
, sampler( sampler_ )
{}
- VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( ImageViewHandleInfoNVX const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , imageView( rhs.imageView )
- , descriptorType( rhs.descriptorType )
- , sampler( rhs.sampler )
- {}
-
ImageViewHandleInfoNVX & operator=( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageViewHandleInfoNVX ) - offsetof( ImageViewHandleInfoNVX, pNext ) );
: usage( usage_ )
{}
- VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( ImageViewUsageCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , usage( rhs.usage )
- {}
-
ImageViewUsageCreateInfo & operator=( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImageViewUsageCreateInfo ) - offsetof( ImageViewUsageCreateInfo, pNext ) );
: buffer( buffer_ )
{}
- VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( ImportAndroidHardwareBufferInfoANDROID const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , buffer( rhs.buffer )
- {}
-
ImportAndroidHardwareBufferInfoANDROID & operator=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportAndroidHardwareBufferInfoANDROID ) - offsetof( ImportAndroidHardwareBufferInfoANDROID, pNext ) );
, fd( fd_ )
{}
- VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( ImportFenceFdInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fence( rhs.fence )
- , flags( rhs.flags )
- , handleType( rhs.handleType )
- , fd( rhs.fd )
- {}
-
ImportFenceFdInfoKHR & operator=( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportFenceFdInfoKHR ) - offsetof( ImportFenceFdInfoKHR, pNext ) );
, name( name_ )
{}
- VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( ImportFenceWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fence( rhs.fence )
- , flags( rhs.flags )
- , handleType( rhs.handleType )
- , handle( rhs.handle )
- , name( rhs.name )
- {}
-
ImportFenceWin32HandleInfoKHR & operator=( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportFenceWin32HandleInfoKHR ) - offsetof( ImportFenceWin32HandleInfoKHR, pNext ) );
, fd( fd_ )
{}
- VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( ImportMemoryFdInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- , fd( rhs.fd )
- {}
-
ImportMemoryFdInfoKHR & operator=( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportMemoryFdInfoKHR ) - offsetof( ImportMemoryFdInfoKHR, pNext ) );
, pHostPointer( pHostPointer_ )
{}
- VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( ImportMemoryHostPointerInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- , pHostPointer( rhs.pHostPointer )
- {}
-
ImportMemoryHostPointerInfoEXT & operator=( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportMemoryHostPointerInfoEXT ) - offsetof( ImportMemoryHostPointerInfoEXT, pNext ) );
, name( name_ )
{}
- VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( ImportMemoryWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- , handle( rhs.handle )
- , name( rhs.name )
- {}
-
ImportMemoryWin32HandleInfoKHR & operator=( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportMemoryWin32HandleInfoKHR ) - offsetof( ImportMemoryWin32HandleInfoKHR, pNext ) );
, handle( handle_ )
{}
- VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( ImportMemoryWin32HandleInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- , handle( rhs.handle )
- {}
-
ImportMemoryWin32HandleInfoNV & operator=( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportMemoryWin32HandleInfoNV ) - offsetof( ImportMemoryWin32HandleInfoNV, pNext ) );
, fd( fd_ )
{}
- VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( ImportSemaphoreFdInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , semaphore( rhs.semaphore )
- , flags( rhs.flags )
- , handleType( rhs.handleType )
- , fd( rhs.fd )
- {}
-
ImportSemaphoreFdInfoKHR & operator=( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportSemaphoreFdInfoKHR ) - offsetof( ImportSemaphoreFdInfoKHR, pNext ) );
, name( name_ )
{}
- VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( ImportSemaphoreWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , semaphore( rhs.semaphore )
- , flags( rhs.flags )
- , handleType( rhs.handleType )
- , handle( rhs.handle )
- , name( rhs.name )
- {}
-
ImportSemaphoreWin32HandleInfoKHR & operator=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ImportSemaphoreWin32HandleInfoKHR ) - offsetof( ImportSemaphoreWin32HandleInfoKHR, pNext ) );
, pIndexTypeValues( pIndexTypeValues_ )
{}
- VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( IndirectCommandsLayoutTokenNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , tokenType( rhs.tokenType )
- , stream( rhs.stream )
- , offset( rhs.offset )
- , vertexBindingUnit( rhs.vertexBindingUnit )
- , vertexDynamicStride( rhs.vertexDynamicStride )
- , pushconstantPipelineLayout( rhs.pushconstantPipelineLayout )
- , pushconstantShaderStageFlags( rhs.pushconstantShaderStageFlags )
- , pushconstantOffset( rhs.pushconstantOffset )
- , pushconstantSize( rhs.pushconstantSize )
- , indirectStateFlags( rhs.indirectStateFlags )
- , indexTypeCount( rhs.indexTypeCount )
- , pIndexTypes( rhs.pIndexTypes )
- , pIndexTypeValues( rhs.pIndexTypeValues )
- {}
-
IndirectCommandsLayoutTokenNV & operator=( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( IndirectCommandsLayoutTokenNV ) - offsetof( IndirectCommandsLayoutTokenNV, pNext ) );
, pStreamStrides( pStreamStrides_ )
{}
- VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pipelineBindPoint( rhs.pipelineBindPoint )
- , tokenCount( rhs.tokenCount )
- , pTokens( rhs.pTokens )
- , streamCount( rhs.streamCount )
- , pStreamStrides( rhs.pStreamStrides )
- {}
-
IndirectCommandsLayoutCreateInfoNV & operator=( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( IndirectCommandsLayoutCreateInfoNV ) - offsetof( IndirectCommandsLayoutCreateInfoNV, pNext ) );
: pUserData( pUserData_ )
{}
- VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( InitializePerformanceApiInfoINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pUserData( rhs.pUserData )
- {}
-
InitializePerformanceApiInfoINTEL & operator=( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( InitializePerformanceApiInfoINTEL ) - offsetof( InitializePerformanceApiInfoINTEL, pNext ) );
, aspectMask( aspectMask_ )
{}
- VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( InputAttachmentAspectReference const& rhs ) VULKAN_HPP_NOEXCEPT
- : subpass( rhs.subpass )
- , inputAttachmentIndex( rhs.inputAttachmentIndex )
- , aspectMask( rhs.aspectMask )
- {}
-
- InputAttachmentAspectReference & operator=( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( InputAttachmentAspectReference ) );
- return *this;
- }
-
InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, ppEnabledExtensionNames( ppEnabledExtensionNames_ )
{}
- VULKAN_HPP_CONSTEXPR InstanceCreateInfo( InstanceCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pApplicationInfo( rhs.pApplicationInfo )
- , enabledLayerCount( rhs.enabledLayerCount )
- , ppEnabledLayerNames( rhs.ppEnabledLayerNames )
- , enabledExtensionCount( rhs.enabledExtensionCount )
- , ppEnabledExtensionNames( rhs.ppEnabledExtensionNames )
- {}
-
InstanceCreateInfo & operator=( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( InstanceCreateInfo ) - offsetof( InstanceCreateInfo, pNext ) );
uint32_t specVersion_ = {},
uint32_t implementationVersion_ = {},
std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {} ) VULKAN_HPP_NOEXCEPT
- : layerName{}
+ : layerName( layerName_ )
, specVersion( specVersion_ )
, implementationVersion( implementationVersion_ )
- , description{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( layerName, layerName_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 LayerProperties( LayerProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : layerName{}
- , specVersion( rhs.specVersion )
- , implementationVersion( rhs.implementationVersion )
- , description{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( layerName, rhs.layerName );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, rhs.description );
- }
-
- LayerProperties & operator=( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( LayerProperties ) );
- return *this;
- }
+ , description( description_ )
+ {}
LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
#else
bool operator==( LayerProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
+ return ( layerName == rhs.layerName )
&& ( specVersion == rhs.specVersion )
&& ( implementationVersion == rhs.implementationVersion )
- && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
+ && ( description == rhs.description );
}
bool operator!=( LayerProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
#endif
public:
- char layerName[VK_MAX_EXTENSION_NAME_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> layerName = {};
uint32_t specVersion = {};
uint32_t implementationVersion = {};
- char description[VK_MAX_DESCRIPTION_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
};
static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<LayerProperties>::value, "struct wrapper is not a standard layout!" );
, pView( pView_ )
{}
- VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateInfoMVK const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pView( rhs.pView )
- {}
-
MacOSSurfaceCreateInfoMVK & operator=( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MacOSSurfaceCreateInfoMVK ) - offsetof( MacOSSurfaceCreateInfoMVK, pNext ) );
, size( size_ )
{}
- VULKAN_HPP_CONSTEXPR MappedMemoryRange( MappedMemoryRange const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memory( rhs.memory )
- , offset( rhs.offset )
- , size( rhs.size )
- {}
-
MappedMemoryRange & operator=( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MappedMemoryRange ) - offsetof( MappedMemoryRange, pNext ) );
, deviceMask( deviceMask_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( MemoryAllocateFlagsInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , deviceMask( rhs.deviceMask )
- {}
-
MemoryAllocateFlagsInfo & operator=( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryAllocateFlagsInfo ) - offsetof( MemoryAllocateFlagsInfo, pNext ) );
, memoryTypeIndex( memoryTypeIndex_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( MemoryAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , allocationSize( rhs.allocationSize )
- , memoryTypeIndex( rhs.memoryTypeIndex )
- {}
-
MemoryAllocateInfo & operator=( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryAllocateInfo ) - offsetof( MemoryAllocateInfo, pNext ) );
, dstAccessMask( dstAccessMask_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryBarrier( MemoryBarrier const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , srcAccessMask( rhs.srcAccessMask )
- , dstAccessMask( rhs.dstAccessMask )
- {}
-
MemoryBarrier & operator=( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryBarrier ) - offsetof( MemoryBarrier, pNext ) );
, buffer( buffer_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( MemoryDedicatedAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , image( rhs.image )
- , buffer( rhs.buffer )
- {}
-
MemoryDedicatedAllocateInfo & operator=( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryDedicatedAllocateInfo ) - offsetof( MemoryDedicatedAllocateInfo, pNext ) );
, requiresDedicatedAllocation( requiresDedicatedAllocation_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( MemoryDedicatedRequirements const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , prefersDedicatedAllocation( rhs.prefersDedicatedAllocation )
- , requiresDedicatedAllocation( rhs.requiresDedicatedAllocation )
- {}
-
MemoryDedicatedRequirements & operator=( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryDedicatedRequirements ) - offsetof( MemoryDedicatedRequirements, pNext ) );
: memoryTypeBits( memoryTypeBits_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( MemoryFdPropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryTypeBits( rhs.memoryTypeBits )
- {}
-
MemoryFdPropertiesKHR & operator=( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryFdPropertiesKHR ) - offsetof( MemoryFdPropertiesKHR, pNext ) );
: memory( memory_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memory( rhs.memory )
- {}
-
MemoryGetAndroidHardwareBufferInfoANDROID & operator=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) - offsetof( MemoryGetAndroidHardwareBufferInfoANDROID, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( MemoryGetFdInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memory( rhs.memory )
- , handleType( rhs.handleType )
- {}
-
MemoryGetFdInfoKHR & operator=( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryGetFdInfoKHR ) - offsetof( MemoryGetFdInfoKHR, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( MemoryGetWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memory( rhs.memory )
- , handleType( rhs.handleType )
- {}
-
MemoryGetWin32HandleInfoKHR & operator=( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryGetWin32HandleInfoKHR ) - offsetof( MemoryGetWin32HandleInfoKHR, pNext ) );
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryHeap( MemoryHeap const& rhs ) VULKAN_HPP_NOEXCEPT
- : size( rhs.size )
- , flags( rhs.flags )
- {}
-
- MemoryHeap & operator=( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( MemoryHeap ) );
- return *this;
- }
-
MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: memoryTypeBits( memoryTypeBits_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( MemoryHostPointerPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryTypeBits( rhs.memoryTypeBits )
- {}
-
MemoryHostPointerPropertiesEXT & operator=( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryHostPointerPropertiesEXT ) - offsetof( MemoryHostPointerPropertiesEXT, pNext ) );
: opaqueCaptureAddress( opaqueCaptureAddress_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( MemoryOpaqueCaptureAddressAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , opaqueCaptureAddress( rhs.opaqueCaptureAddress )
- {}
-
MemoryOpaqueCaptureAddressAllocateInfo & operator=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryOpaqueCaptureAddressAllocateInfo ) - offsetof( MemoryOpaqueCaptureAddressAllocateInfo, pNext ) );
: priority( priority_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( MemoryPriorityAllocateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , priority( rhs.priority )
- {}
-
MemoryPriorityAllocateInfoEXT & operator=( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryPriorityAllocateInfoEXT ) - offsetof( MemoryPriorityAllocateInfoEXT, pNext ) );
, memoryTypeBits( memoryTypeBits_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryRequirements( MemoryRequirements const& rhs ) VULKAN_HPP_NOEXCEPT
- : size( rhs.size )
- , alignment( rhs.alignment )
- , memoryTypeBits( rhs.memoryTypeBits )
- {}
-
- MemoryRequirements & operator=( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( MemoryRequirements ) );
- return *this;
- }
-
MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: memoryRequirements( memoryRequirements_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryRequirements2( MemoryRequirements2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryRequirements( rhs.memoryRequirements )
- {}
-
MemoryRequirements2 & operator=( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryRequirements2 ) - offsetof( MemoryRequirements2, pNext ) );
, heapIndex( heapIndex_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryType( MemoryType const& rhs ) VULKAN_HPP_NOEXCEPT
- : propertyFlags( rhs.propertyFlags )
- , heapIndex( rhs.heapIndex )
- {}
-
- MemoryType & operator=( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( MemoryType ) );
- return *this;
- }
-
MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: memoryTypeBits( memoryTypeBits_ )
{}
- VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( MemoryWin32HandlePropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryTypeBits( rhs.memoryTypeBits )
- {}
-
MemoryWin32HandlePropertiesKHR & operator=( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MemoryWin32HandlePropertiesKHR ) - offsetof( MemoryWin32HandlePropertiesKHR, pNext ) );
, pLayer( pLayer_ )
{}
- VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( MetalSurfaceCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pLayer( rhs.pLayer )
- {}
-
MetalSurfaceCreateInfoEXT & operator=( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MetalSurfaceCreateInfoEXT ) - offsetof( MetalSurfaceCreateInfoEXT, pNext ) );
: maxSampleLocationGridSize( maxSampleLocationGridSize_ )
{}
- VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( MultisamplePropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxSampleLocationGridSize( rhs.maxSampleLocationGridSize )
- {}
-
MultisamplePropertiesEXT & operator=( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( MultisamplePropertiesEXT ) - offsetof( MultisamplePropertiesEXT, pNext ) );
, presentMargin( presentMargin_ )
{}
- VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( PastPresentationTimingGOOGLE const& rhs ) VULKAN_HPP_NOEXCEPT
- : presentID( rhs.presentID )
- , desiredPresentTime( rhs.desiredPresentTime )
- , actualPresentTime( rhs.actualPresentTime )
- , earliestPresentTime( rhs.earliestPresentTime )
- , presentMargin( rhs.presentMargin )
- {}
-
- PastPresentationTimingGOOGLE & operator=( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PastPresentationTimingGOOGLE ) );
- return *this;
- }
-
PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: type( type_ )
{}
- VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationAcquireInfoINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- {}
-
PerformanceConfigurationAcquireInfoINTEL & operator=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PerformanceConfigurationAcquireInfoINTEL ) - offsetof( PerformanceConfigurationAcquireInfoINTEL, pNext ) );
std::array<char,VK_MAX_DESCRIPTION_SIZE> const& category_ = {},
std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {} ) VULKAN_HPP_NOEXCEPT
: flags( flags_ )
- , name{}
- , category{}
- , description{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( category, category_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( PerformanceCounterDescriptionKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , name{}
- , category{}
- , description{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, rhs.name );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( category, rhs.category );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, rhs.description );
- }
+ , name( name_ )
+ , category( category_ )
+ , description( description_ )
+ {}
PerformanceCounterDescriptionKHR & operator=( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( category, rhs.category, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
+ && ( name == rhs.name )
+ && ( category == rhs.category )
+ && ( description == rhs.description );
}
bool operator!=( PerformanceCounterDescriptionKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceCounterDescriptionKHR;
const void* pNext = {};
VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR flags = {};
- char name[VK_MAX_DESCRIPTION_SIZE] = {};
- char category[VK_MAX_DESCRIPTION_SIZE] = {};
- char description[VK_MAX_DESCRIPTION_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> category = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
};
static_assert( sizeof( PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PerformanceCounterDescriptionKHR>::value, "struct wrapper is not a standard layout!" );
: unit( unit_ )
, scope( scope_ )
, storage( storage_ )
- , uuid{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( uuid, uuid_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( PerformanceCounterKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , unit( rhs.unit )
- , scope( rhs.scope )
- , storage( rhs.storage )
- , uuid{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( uuid, rhs.uuid );
- }
+ , uuid( uuid_ )
+ {}
PerformanceCounterKHR & operator=( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
&& ( unit == rhs.unit )
&& ( scope == rhs.scope )
&& ( storage == rhs.storage )
- && ( memcmp( uuid, rhs.uuid, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 );
+ && ( uuid == rhs.uuid );
}
bool operator!=( PerformanceCounterKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR unit = VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR::eGeneric;
VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR scope = VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR::eCommandBuffer;
VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR storage = VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR::eInt32;
- uint8_t uuid[VK_UUID_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> uuid = {};
};
static_assert( sizeof( PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PerformanceCounterKHR>::value, "struct wrapper is not a standard layout!" );
: marker( marker_ )
{}
- VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( PerformanceMarkerInfoINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , marker( rhs.marker )
- {}
-
PerformanceMarkerInfoINTEL & operator=( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PerformanceMarkerInfoINTEL ) - offsetof( PerformanceMarkerInfoINTEL, pNext ) );
, parameter( parameter_ )
{}
- VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( PerformanceOverrideInfoINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , enable( rhs.enable )
- , parameter( rhs.parameter )
- {}
-
PerformanceOverrideInfoINTEL & operator=( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PerformanceOverrideInfoINTEL ) - offsetof( PerformanceOverrideInfoINTEL, pNext ) );
: counterPassIndex( counterPassIndex_ )
{}
- VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( PerformanceQuerySubmitInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , counterPassIndex( rhs.counterPassIndex )
- {}
-
PerformanceQuerySubmitInfoKHR & operator=( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PerformanceQuerySubmitInfoKHR ) - offsetof( PerformanceQuerySubmitInfoKHR, pNext ) );
: marker( marker_ )
{}
- VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( PerformanceStreamMarkerInfoINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , marker( rhs.marker )
- {}
-
PerformanceStreamMarkerInfoINTEL & operator=( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PerformanceStreamMarkerInfoINTEL ) - offsetof( PerformanceStreamMarkerInfoINTEL, pNext ) );
, data( data_ )
{}
- PerformanceValueINTEL( PerformanceValueINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : type( rhs.type )
- , data( rhs.data )
- {}
-
- PerformanceValueINTEL & operator=( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PerformanceValueINTEL ) );
- return *this;
- }
-
PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, storageInputOutput16( storageInputOutput16_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( PhysicalDevice16BitStorageFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , storageBuffer16BitAccess( rhs.storageBuffer16BitAccess )
- , uniformAndStorageBuffer16BitAccess( rhs.uniformAndStorageBuffer16BitAccess )
- , storagePushConstant16( rhs.storagePushConstant16 )
- , storageInputOutput16( rhs.storageInputOutput16 )
- {}
-
PhysicalDevice16BitStorageFeatures & operator=( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevice16BitStorageFeatures ) - offsetof( PhysicalDevice16BitStorageFeatures, pNext ) );
, storagePushConstant8( storagePushConstant8_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( PhysicalDevice8BitStorageFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , storageBuffer8BitAccess( rhs.storageBuffer8BitAccess )
- , uniformAndStorageBuffer8BitAccess( rhs.uniformAndStorageBuffer8BitAccess )
- , storagePushConstant8( rhs.storagePushConstant8 )
- {}
-
PhysicalDevice8BitStorageFeatures & operator=( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevice8BitStorageFeatures ) - offsetof( PhysicalDevice8BitStorageFeatures, pNext ) );
: decodeModeSharedExponent( decodeModeSharedExponent_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , decodeModeSharedExponent( rhs.decodeModeSharedExponent )
- {}
-
PhysicalDeviceASTCDecodeFeaturesEXT & operator=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) - offsetof( PhysicalDeviceASTCDecodeFeaturesEXT, pNext ) );
: advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , advancedBlendCoherentOperations( rhs.advancedBlendCoherentOperations )
- {}
-
PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) - offsetof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext ) );
, advancedBlendAllOperations( advancedBlendAllOperations_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , advancedBlendMaxColorAttachments( rhs.advancedBlendMaxColorAttachments )
- , advancedBlendIndependentBlend( rhs.advancedBlendIndependentBlend )
- , advancedBlendNonPremultipliedSrcColor( rhs.advancedBlendNonPremultipliedSrcColor )
- , advancedBlendNonPremultipliedDstColor( rhs.advancedBlendNonPremultipliedDstColor )
- , advancedBlendCorrelatedOverlap( rhs.advancedBlendCorrelatedOverlap )
- , advancedBlendAllOperations( rhs.advancedBlendAllOperations )
- {}
-
PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) - offsetof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext ) );
, bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( PhysicalDeviceBufferDeviceAddressFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , bufferDeviceAddress( rhs.bufferDeviceAddress )
- , bufferDeviceAddressCaptureReplay( rhs.bufferDeviceAddressCaptureReplay )
- , bufferDeviceAddressMultiDevice( rhs.bufferDeviceAddressMultiDevice )
- {}
-
PhysicalDeviceBufferDeviceAddressFeatures & operator=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceBufferDeviceAddressFeatures ) - offsetof( PhysicalDeviceBufferDeviceAddressFeatures, pNext ) );
, bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( PhysicalDeviceBufferDeviceAddressFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , bufferDeviceAddress( rhs.bufferDeviceAddress )
- , bufferDeviceAddressCaptureReplay( rhs.bufferDeviceAddressCaptureReplay )
- , bufferDeviceAddressMultiDevice( rhs.bufferDeviceAddressMultiDevice )
- {}
-
PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) - offsetof( PhysicalDeviceBufferDeviceAddressFeaturesEXT, pNext ) );
: deviceCoherentMemory( deviceCoherentMemory_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( PhysicalDeviceCoherentMemoryFeaturesAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceCoherentMemory( rhs.deviceCoherentMemory )
- {}
-
PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) - offsetof( PhysicalDeviceCoherentMemoryFeaturesAMD, pNext ) );
, computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , computeDerivativeGroupQuads( rhs.computeDerivativeGroupQuads )
- , computeDerivativeGroupLinear( rhs.computeDerivativeGroupLinear )
- {}
-
PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) - offsetof( PhysicalDeviceComputeShaderDerivativesFeaturesNV, pNext ) );
, inheritedConditionalRendering( inheritedConditionalRendering_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , conditionalRendering( rhs.conditionalRendering )
- , inheritedConditionalRendering( rhs.inheritedConditionalRendering )
- {}
-
PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) - offsetof( PhysicalDeviceConditionalRenderingFeaturesEXT, pNext ) );
, conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , primitiveOverestimationSize( rhs.primitiveOverestimationSize )
- , maxExtraPrimitiveOverestimationSize( rhs.maxExtraPrimitiveOverestimationSize )
- , extraPrimitiveOverestimationSizeGranularity( rhs.extraPrimitiveOverestimationSizeGranularity )
- , primitiveUnderestimation( rhs.primitiveUnderestimation )
- , conservativePointAndLineRasterization( rhs.conservativePointAndLineRasterization )
- , degenerateTrianglesRasterized( rhs.degenerateTrianglesRasterized )
- , degenerateLinesRasterized( rhs.degenerateLinesRasterized )
- , fullyCoveredFragmentShaderInputVariable( rhs.fullyCoveredFragmentShaderInputVariable )
- , conservativeRasterizationPostDepthCoverage( rhs.conservativeRasterizationPostDepthCoverage )
- {}
-
PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) - offsetof( PhysicalDeviceConservativeRasterizationPropertiesEXT, pNext ) );
, cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( PhysicalDeviceCooperativeMatrixFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , cooperativeMatrix( rhs.cooperativeMatrix )
- , cooperativeMatrixRobustBufferAccess( rhs.cooperativeMatrixRobustBufferAccess )
- {}
-
PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) - offsetof( PhysicalDeviceCooperativeMatrixFeaturesNV, pNext ) );
: cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( PhysicalDeviceCooperativeMatrixPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , cooperativeMatrixSupportedStages( rhs.cooperativeMatrixSupportedStages )
- {}
-
PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) - offsetof( PhysicalDeviceCooperativeMatrixPropertiesNV, pNext ) );
: cornerSampledImage( cornerSampledImage_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , cornerSampledImage( rhs.cornerSampledImage )
- {}
-
PhysicalDeviceCornerSampledImageFeaturesNV & operator=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) - offsetof( PhysicalDeviceCornerSampledImageFeaturesNV, pNext ) );
: coverageReductionMode( coverageReductionMode_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( PhysicalDeviceCoverageReductionModeFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , coverageReductionMode( rhs.coverageReductionMode )
- {}
-
PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) - offsetof( PhysicalDeviceCoverageReductionModeFeaturesNV, pNext ) );
: dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , dedicatedAllocationImageAliasing( rhs.dedicatedAllocationImageAliasing )
- {}
-
PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & operator=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) - offsetof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, pNext ) );
: depthClipEnable( depthClipEnable_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( PhysicalDeviceDepthClipEnableFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , depthClipEnable( rhs.depthClipEnable )
- {}
-
PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) - offsetof( PhysicalDeviceDepthClipEnableFeaturesEXT, pNext ) );
, independentResolve( independentResolve_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( PhysicalDeviceDepthStencilResolveProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , supportedDepthResolveModes( rhs.supportedDepthResolveModes )
- , supportedStencilResolveModes( rhs.supportedStencilResolveModes )
- , independentResolveNone( rhs.independentResolveNone )
- , independentResolve( rhs.independentResolve )
- {}
-
PhysicalDeviceDepthStencilResolveProperties & operator=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDepthStencilResolveProperties ) - offsetof( PhysicalDeviceDepthStencilResolveProperties, pNext ) );
, runtimeDescriptorArray( runtimeDescriptorArray_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( PhysicalDeviceDescriptorIndexingFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderInputAttachmentArrayDynamicIndexing( rhs.shaderInputAttachmentArrayDynamicIndexing )
- , shaderUniformTexelBufferArrayDynamicIndexing( rhs.shaderUniformTexelBufferArrayDynamicIndexing )
- , shaderStorageTexelBufferArrayDynamicIndexing( rhs.shaderStorageTexelBufferArrayDynamicIndexing )
- , shaderUniformBufferArrayNonUniformIndexing( rhs.shaderUniformBufferArrayNonUniformIndexing )
- , shaderSampledImageArrayNonUniformIndexing( rhs.shaderSampledImageArrayNonUniformIndexing )
- , shaderStorageBufferArrayNonUniformIndexing( rhs.shaderStorageBufferArrayNonUniformIndexing )
- , shaderStorageImageArrayNonUniformIndexing( rhs.shaderStorageImageArrayNonUniformIndexing )
- , shaderInputAttachmentArrayNonUniformIndexing( rhs.shaderInputAttachmentArrayNonUniformIndexing )
- , shaderUniformTexelBufferArrayNonUniformIndexing( rhs.shaderUniformTexelBufferArrayNonUniformIndexing )
- , shaderStorageTexelBufferArrayNonUniformIndexing( rhs.shaderStorageTexelBufferArrayNonUniformIndexing )
- , descriptorBindingUniformBufferUpdateAfterBind( rhs.descriptorBindingUniformBufferUpdateAfterBind )
- , descriptorBindingSampledImageUpdateAfterBind( rhs.descriptorBindingSampledImageUpdateAfterBind )
- , descriptorBindingStorageImageUpdateAfterBind( rhs.descriptorBindingStorageImageUpdateAfterBind )
- , descriptorBindingStorageBufferUpdateAfterBind( rhs.descriptorBindingStorageBufferUpdateAfterBind )
- , descriptorBindingUniformTexelBufferUpdateAfterBind( rhs.descriptorBindingUniformTexelBufferUpdateAfterBind )
- , descriptorBindingStorageTexelBufferUpdateAfterBind( rhs.descriptorBindingStorageTexelBufferUpdateAfterBind )
- , descriptorBindingUpdateUnusedWhilePending( rhs.descriptorBindingUpdateUnusedWhilePending )
- , descriptorBindingPartiallyBound( rhs.descriptorBindingPartiallyBound )
- , descriptorBindingVariableDescriptorCount( rhs.descriptorBindingVariableDescriptorCount )
- , runtimeDescriptorArray( rhs.runtimeDescriptorArray )
- {}
-
PhysicalDeviceDescriptorIndexingFeatures & operator=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDescriptorIndexingFeatures ) - offsetof( PhysicalDeviceDescriptorIndexingFeatures, pNext ) );
, maxDescriptorSetUpdateAfterBindInputAttachments( maxDescriptorSetUpdateAfterBindInputAttachments_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( PhysicalDeviceDescriptorIndexingProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxUpdateAfterBindDescriptorsInAllPools( rhs.maxUpdateAfterBindDescriptorsInAllPools )
- , shaderUniformBufferArrayNonUniformIndexingNative( rhs.shaderUniformBufferArrayNonUniformIndexingNative )
- , shaderSampledImageArrayNonUniformIndexingNative( rhs.shaderSampledImageArrayNonUniformIndexingNative )
- , shaderStorageBufferArrayNonUniformIndexingNative( rhs.shaderStorageBufferArrayNonUniformIndexingNative )
- , shaderStorageImageArrayNonUniformIndexingNative( rhs.shaderStorageImageArrayNonUniformIndexingNative )
- , shaderInputAttachmentArrayNonUniformIndexingNative( rhs.shaderInputAttachmentArrayNonUniformIndexingNative )
- , robustBufferAccessUpdateAfterBind( rhs.robustBufferAccessUpdateAfterBind )
- , quadDivergentImplicitLod( rhs.quadDivergentImplicitLod )
- , maxPerStageDescriptorUpdateAfterBindSamplers( rhs.maxPerStageDescriptorUpdateAfterBindSamplers )
- , maxPerStageDescriptorUpdateAfterBindUniformBuffers( rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers )
- , maxPerStageDescriptorUpdateAfterBindStorageBuffers( rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers )
- , maxPerStageDescriptorUpdateAfterBindSampledImages( rhs.maxPerStageDescriptorUpdateAfterBindSampledImages )
- , maxPerStageDescriptorUpdateAfterBindStorageImages( rhs.maxPerStageDescriptorUpdateAfterBindStorageImages )
- , maxPerStageDescriptorUpdateAfterBindInputAttachments( rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments )
- , maxPerStageUpdateAfterBindResources( rhs.maxPerStageUpdateAfterBindResources )
- , maxDescriptorSetUpdateAfterBindSamplers( rhs.maxDescriptorSetUpdateAfterBindSamplers )
- , maxDescriptorSetUpdateAfterBindUniformBuffers( rhs.maxDescriptorSetUpdateAfterBindUniformBuffers )
- , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic( rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic )
- , maxDescriptorSetUpdateAfterBindStorageBuffers( rhs.maxDescriptorSetUpdateAfterBindStorageBuffers )
- , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic( rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic )
- , maxDescriptorSetUpdateAfterBindSampledImages( rhs.maxDescriptorSetUpdateAfterBindSampledImages )
- , maxDescriptorSetUpdateAfterBindStorageImages( rhs.maxDescriptorSetUpdateAfterBindStorageImages )
- , maxDescriptorSetUpdateAfterBindInputAttachments( rhs.maxDescriptorSetUpdateAfterBindInputAttachments )
- {}
-
PhysicalDeviceDescriptorIndexingProperties & operator=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDescriptorIndexingProperties ) - offsetof( PhysicalDeviceDescriptorIndexingProperties, pNext ) );
: deviceGeneratedCommands( deviceGeneratedCommands_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceGeneratedCommands( rhs.deviceGeneratedCommands )
- {}
-
PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) - offsetof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, pNext ) );
, minIndirectCommandsBufferOffsetAlignment( minIndirectCommandsBufferOffsetAlignment_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxGraphicsShaderGroupCount( rhs.maxGraphicsShaderGroupCount )
- , maxIndirectSequenceCount( rhs.maxIndirectSequenceCount )
- , maxIndirectCommandsTokenCount( rhs.maxIndirectCommandsTokenCount )
- , maxIndirectCommandsStreamCount( rhs.maxIndirectCommandsStreamCount )
- , maxIndirectCommandsTokenOffset( rhs.maxIndirectCommandsTokenOffset )
- , maxIndirectCommandsStreamStride( rhs.maxIndirectCommandsStreamStride )
- , minSequencesCountBufferOffsetAlignment( rhs.minSequencesCountBufferOffsetAlignment )
- , minSequencesIndexBufferOffsetAlignment( rhs.minSequencesIndexBufferOffsetAlignment )
- , minIndirectCommandsBufferOffsetAlignment( rhs.minIndirectCommandsBufferOffsetAlignment )
- {}
-
PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) - offsetof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, pNext ) );
: diagnosticsConfig( diagnosticsConfig_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( PhysicalDeviceDiagnosticsConfigFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , diagnosticsConfig( rhs.diagnosticsConfig )
- {}
-
PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDiagnosticsConfigFeaturesNV ) - offsetof( PhysicalDeviceDiagnosticsConfigFeaturesNV, pNext ) );
: maxDiscardRectangles( maxDiscardRectangles_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxDiscardRectangles( rhs.maxDiscardRectangles )
- {}
-
PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) - offsetof( PhysicalDeviceDiscardRectanglePropertiesEXT, pNext ) );
std::array<char,VK_MAX_DRIVER_INFO_SIZE> const& driverInfo_ = {},
VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion_ = {} ) VULKAN_HPP_NOEXCEPT
: driverID( driverID_ )
- , driverName{}
- , driverInfo{}
+ , driverName( driverName_ )
+ , driverInfo( driverInfo_ )
, conformanceVersion( conformanceVersion_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_NAME_SIZE>::copy( driverName, driverName_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_INFO_SIZE>::copy( driverInfo, driverInfo_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( PhysicalDeviceDriverProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , driverID( rhs.driverID )
- , driverName{}
- , driverInfo{}
- , conformanceVersion( rhs.conformanceVersion )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_NAME_SIZE>::copy( driverName, rhs.driverName );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_INFO_SIZE>::copy( driverInfo, rhs.driverInfo );
- }
+ {}
PhysicalDeviceDriverProperties & operator=( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( driverID == rhs.driverID )
- && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof( char ) ) == 0 )
+ && ( driverName == rhs.driverName )
+ && ( driverInfo == rhs.driverInfo )
&& ( conformanceVersion == rhs.conformanceVersion );
}
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDriverProperties;
void* pNext = {};
VULKAN_HPP_NAMESPACE::DriverId driverID = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary;
- char driverName[VK_MAX_DRIVER_NAME_SIZE] = {};
- char driverInfo[VK_MAX_DRIVER_INFO_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> driverName = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> driverInfo = {};
VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion = {};
};
static_assert( sizeof( PhysicalDeviceDriverProperties ) == sizeof( VkPhysicalDeviceDriverProperties ), "struct and wrapper have different size!" );
: exclusiveScissor( exclusiveScissor_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , exclusiveScissor( rhs.exclusiveScissor )
- {}
-
PhysicalDeviceExclusiveScissorFeaturesNV & operator=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) - offsetof( PhysicalDeviceExclusiveScissorFeaturesNV, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( PhysicalDeviceExternalBufferInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , usage( rhs.usage )
- , handleType( rhs.handleType )
- {}
-
PhysicalDeviceExternalBufferInfo & operator=( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceExternalBufferInfo ) - offsetof( PhysicalDeviceExternalBufferInfo, pNext ) );
: handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( PhysicalDeviceExternalFenceInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- {}
-
PhysicalDeviceExternalFenceInfo & operator=( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceExternalFenceInfo ) - offsetof( PhysicalDeviceExternalFenceInfo, pNext ) );
: handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( PhysicalDeviceExternalImageFormatInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- {}
-
PhysicalDeviceExternalImageFormatInfo & operator=( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceExternalImageFormatInfo ) - offsetof( PhysicalDeviceExternalImageFormatInfo, pNext ) );
: minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , minImportedHostPointerAlignment( rhs.minImportedHostPointerAlignment )
- {}
-
PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) - offsetof( PhysicalDeviceExternalMemoryHostPropertiesEXT, pNext ) );
: handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( PhysicalDeviceExternalSemaphoreInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , handleType( rhs.handleType )
- {}
-
PhysicalDeviceExternalSemaphoreInfo & operator=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceExternalSemaphoreInfo ) - offsetof( PhysicalDeviceExternalSemaphoreInfo, pNext ) );
: features( features_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( PhysicalDeviceFeatures2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , features( rhs.features )
- {}
-
PhysicalDeviceFeatures2 & operator=( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFeatures2 ) - offsetof( PhysicalDeviceFeatures2, pNext ) );
, shaderRoundingModeRTZFloat64( shaderRoundingModeRTZFloat64_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( PhysicalDeviceFloatControlsProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , denormBehaviorIndependence( rhs.denormBehaviorIndependence )
- , roundingModeIndependence( rhs.roundingModeIndependence )
- , shaderSignedZeroInfNanPreserveFloat16( rhs.shaderSignedZeroInfNanPreserveFloat16 )
- , shaderSignedZeroInfNanPreserveFloat32( rhs.shaderSignedZeroInfNanPreserveFloat32 )
- , shaderSignedZeroInfNanPreserveFloat64( rhs.shaderSignedZeroInfNanPreserveFloat64 )
- , shaderDenormPreserveFloat16( rhs.shaderDenormPreserveFloat16 )
- , shaderDenormPreserveFloat32( rhs.shaderDenormPreserveFloat32 )
- , shaderDenormPreserveFloat64( rhs.shaderDenormPreserveFloat64 )
- , shaderDenormFlushToZeroFloat16( rhs.shaderDenormFlushToZeroFloat16 )
- , shaderDenormFlushToZeroFloat32( rhs.shaderDenormFlushToZeroFloat32 )
- , shaderDenormFlushToZeroFloat64( rhs.shaderDenormFlushToZeroFloat64 )
- , shaderRoundingModeRTEFloat16( rhs.shaderRoundingModeRTEFloat16 )
- , shaderRoundingModeRTEFloat32( rhs.shaderRoundingModeRTEFloat32 )
- , shaderRoundingModeRTEFloat64( rhs.shaderRoundingModeRTEFloat64 )
- , shaderRoundingModeRTZFloat16( rhs.shaderRoundingModeRTZFloat16 )
- , shaderRoundingModeRTZFloat32( rhs.shaderRoundingModeRTZFloat32 )
- , shaderRoundingModeRTZFloat64( rhs.shaderRoundingModeRTZFloat64 )
- {}
-
PhysicalDeviceFloatControlsProperties & operator=( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFloatControlsProperties ) - offsetof( PhysicalDeviceFloatControlsProperties, pNext ) );
, fragmentDensityMapNonSubsampledImages( fragmentDensityMapNonSubsampledImages_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( PhysicalDeviceFragmentDensityMapFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fragmentDensityMap( rhs.fragmentDensityMap )
- , fragmentDensityMapDynamic( rhs.fragmentDensityMapDynamic )
- , fragmentDensityMapNonSubsampledImages( rhs.fragmentDensityMapNonSubsampledImages )
- {}
-
PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) - offsetof( PhysicalDeviceFragmentDensityMapFeaturesEXT, pNext ) );
, fragmentDensityInvocations( fragmentDensityInvocations_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( PhysicalDeviceFragmentDensityMapPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , minFragmentDensityTexelSize( rhs.minFragmentDensityTexelSize )
- , maxFragmentDensityTexelSize( rhs.maxFragmentDensityTexelSize )
- , fragmentDensityInvocations( rhs.fragmentDensityInvocations )
- {}
-
PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) - offsetof( PhysicalDeviceFragmentDensityMapPropertiesEXT, pNext ) );
: fragmentShaderBarycentric( fragmentShaderBarycentric_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fragmentShaderBarycentric( rhs.fragmentShaderBarycentric )
- {}
-
PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) - offsetof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV, pNext ) );
, fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fragmentShaderSampleInterlock( rhs.fragmentShaderSampleInterlock )
- , fragmentShaderPixelInterlock( rhs.fragmentShaderPixelInterlock )
- , fragmentShaderShadingRateInterlock( rhs.fragmentShaderShadingRateInterlock )
- {}
-
PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) - offsetof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT, pNext ) );
std::array<VULKAN_HPP_NAMESPACE::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE> const& physicalDevices_ = {},
VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation_ = {} ) VULKAN_HPP_NOEXCEPT
: physicalDeviceCount( physicalDeviceCount_ )
- , physicalDevices{}
+ , physicalDevices( physicalDevices_ )
, subsetAllocation( subsetAllocation_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE>::copy( physicalDevices, physicalDevices_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( PhysicalDeviceGroupProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , physicalDeviceCount( rhs.physicalDeviceCount )
- , physicalDevices{}
- , subsetAllocation( rhs.subsetAllocation )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE>::copy( physicalDevices, rhs.physicalDevices );
- }
+ {}
PhysicalDeviceGroupProperties & operator=( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( physicalDeviceCount == rhs.physicalDeviceCount )
- && ( memcmp( physicalDevices, rhs.physicalDevices, std::min<uint32_t>( VK_MAX_DEVICE_GROUP_SIZE, physicalDeviceCount ) * sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) ) == 0 )
+ && ( physicalDevices == rhs.physicalDevices )
&& ( subsetAllocation == rhs.subsetAllocation );
}
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
void* pNext = {};
uint32_t physicalDeviceCount = {};
- VULKAN_HPP_NAMESPACE::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::PhysicalDevice, VK_MAX_DEVICE_GROUP_SIZE> physicalDevices = {};
VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation = {};
};
static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" );
: hostQueryReset( hostQueryReset_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( PhysicalDeviceHostQueryResetFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , hostQueryReset( rhs.hostQueryReset )
- {}
-
PhysicalDeviceHostQueryResetFeatures & operator=( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceHostQueryResetFeatures ) - offsetof( PhysicalDeviceHostQueryResetFeatures, pNext ) );
std::array<uint8_t,VK_LUID_SIZE> const& deviceLUID_ = {},
uint32_t deviceNodeMask_ = {},
VULKAN_HPP_NAMESPACE::Bool32 deviceLUIDValid_ = {} ) VULKAN_HPP_NOEXCEPT
- : deviceUUID{}
- , driverUUID{}
- , deviceLUID{}
+ : deviceUUID( deviceUUID_ )
+ , driverUUID( driverUUID_ )
+ , deviceLUID( deviceLUID_ )
, deviceNodeMask( deviceNodeMask_ )
, deviceLUIDValid( deviceLUIDValid_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( deviceUUID, deviceUUID_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( driverUUID, driverUUID_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_LUID_SIZE>::copy( deviceLUID, deviceLUID_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( PhysicalDeviceIDProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceUUID{}
- , driverUUID{}
- , deviceLUID{}
- , deviceNodeMask( rhs.deviceNodeMask )
- , deviceLUIDValid( rhs.deviceLUIDValid )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( deviceUUID, rhs.deviceUUID );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( driverUUID, rhs.driverUUID );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_LUID_SIZE>::copy( deviceLUID, rhs.deviceLUID );
- }
+ {}
PhysicalDeviceIDProperties & operator=( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( 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 * sizeof( uint8_t ) ) == 0 )
+ && ( deviceUUID == rhs.deviceUUID )
+ && ( driverUUID == rhs.driverUUID )
+ && ( deviceLUID == rhs.deviceLUID )
&& ( deviceNodeMask == rhs.deviceNodeMask )
&& ( deviceLUIDValid == rhs.deviceLUIDValid );
}
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceIdProperties;
void* pNext = {};
- uint8_t deviceUUID[VK_UUID_SIZE] = {};
- uint8_t driverUUID[VK_UUID_SIZE] = {};
- uint8_t deviceLUID[VK_LUID_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> deviceUUID = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> driverUUID = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> deviceLUID = {};
uint32_t deviceNodeMask = {};
VULKAN_HPP_NAMESPACE::Bool32 deviceLUIDValid = {};
};
, pQueueFamilyIndices( pQueueFamilyIndices_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , drmFormatModifier( rhs.drmFormatModifier )
- , sharingMode( rhs.sharingMode )
- , queueFamilyIndexCount( rhs.queueFamilyIndexCount )
- , pQueueFamilyIndices( rhs.pQueueFamilyIndices )
- {}
-
PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) - offsetof( PhysicalDeviceImageDrmFormatModifierInfoEXT, pNext ) );
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( PhysicalDeviceImageFormatInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , format( rhs.format )
- , type( rhs.type )
- , tiling( rhs.tiling )
- , usage( rhs.usage )
- , flags( rhs.flags )
- {}
-
PhysicalDeviceImageFormatInfo2 & operator=( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceImageFormatInfo2 ) - offsetof( PhysicalDeviceImageFormatInfo2, pNext ) );
: imageViewType( imageViewType_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( PhysicalDeviceImageViewImageFormatInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , imageViewType( rhs.imageViewType )
- {}
-
PhysicalDeviceImageViewImageFormatInfoEXT & operator=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) - offsetof( PhysicalDeviceImageViewImageFormatInfoEXT, pNext ) );
: imagelessFramebuffer( imagelessFramebuffer_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( PhysicalDeviceImagelessFramebufferFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , imagelessFramebuffer( rhs.imagelessFramebuffer )
- {}
-
PhysicalDeviceImagelessFramebufferFeatures & operator=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceImagelessFramebufferFeatures ) - offsetof( PhysicalDeviceImagelessFramebufferFeatures, pNext ) );
: indexTypeUint8( indexTypeUint8_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , indexTypeUint8( rhs.indexTypeUint8 )
- {}
-
PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) - offsetof( PhysicalDeviceIndexTypeUint8FeaturesEXT, pNext ) );
, descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , inlineUniformBlock( rhs.inlineUniformBlock )
- , descriptorBindingInlineUniformBlockUpdateAfterBind( rhs.descriptorBindingInlineUniformBlockUpdateAfterBind )
- {}
-
PhysicalDeviceInlineUniformBlockFeaturesEXT & operator=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) - offsetof( PhysicalDeviceInlineUniformBlockFeaturesEXT, pNext ) );
, maxDescriptorSetUpdateAfterBindInlineUniformBlocks( maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockPropertiesEXT( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxInlineUniformBlockSize( rhs.maxInlineUniformBlockSize )
- , maxPerStageDescriptorInlineUniformBlocks( rhs.maxPerStageDescriptorInlineUniformBlocks )
- , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks( rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks )
- , maxDescriptorSetInlineUniformBlocks( rhs.maxDescriptorSetInlineUniformBlocks )
- , maxDescriptorSetUpdateAfterBindInlineUniformBlocks( rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks )
- {}
-
PhysicalDeviceInlineUniformBlockPropertiesEXT & operator=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) - offsetof( PhysicalDeviceInlineUniformBlockPropertiesEXT, pNext ) );
, maxFragmentDualSrcAttachments( maxFragmentDualSrcAttachments_ )
, maxFragmentCombinedOutputResources( maxFragmentCombinedOutputResources_ )
, maxComputeSharedMemorySize( maxComputeSharedMemorySize_ )
- , maxComputeWorkGroupCount{}
+ , maxComputeWorkGroupCount( maxComputeWorkGroupCount_ )
, maxComputeWorkGroupInvocations( maxComputeWorkGroupInvocations_ )
- , maxComputeWorkGroupSize{}
+ , maxComputeWorkGroupSize( maxComputeWorkGroupSize_ )
, subPixelPrecisionBits( subPixelPrecisionBits_ )
, subTexelPrecisionBits( subTexelPrecisionBits_ )
, mipmapPrecisionBits( mipmapPrecisionBits_ )
, maxSamplerLodBias( maxSamplerLodBias_ )
, maxSamplerAnisotropy( maxSamplerAnisotropy_ )
, maxViewports( maxViewports_ )
- , maxViewportDimensions{}
- , viewportBoundsRange{}
+ , maxViewportDimensions( maxViewportDimensions_ )
+ , viewportBoundsRange( viewportBoundsRange_ )
, viewportSubPixelBits( viewportSubPixelBits_ )
, minMemoryMapAlignment( minMemoryMapAlignment_ )
, minTexelBufferOffsetAlignment( minTexelBufferOffsetAlignment_ )
, maxCullDistances( maxCullDistances_ )
, maxCombinedClipAndCullDistances( maxCombinedClipAndCullDistances_ )
, discreteQueuePriorities( discreteQueuePriorities_ )
- , pointSizeRange{}
- , lineWidthRange{}
+ , pointSizeRange( pointSizeRange_ )
+ , lineWidthRange( lineWidthRange_ )
, pointSizeGranularity( pointSizeGranularity_ )
, lineWidthGranularity( lineWidthGranularity_ )
, strictLines( strictLines_ )
, optimalBufferCopyOffsetAlignment( optimalBufferCopyOffsetAlignment_ )
, optimalBufferCopyRowPitchAlignment( optimalBufferCopyRowPitchAlignment_ )
, nonCoherentAtomSize( nonCoherentAtomSize_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxComputeWorkGroupCount, maxComputeWorkGroupCount_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxComputeWorkGroupSize, maxComputeWorkGroupSize_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,2>::copy( maxViewportDimensions, maxViewportDimensions_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( viewportBoundsRange, viewportBoundsRange_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( pointSizeRange, pointSizeRange_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( lineWidthRange, lineWidthRange_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( PhysicalDeviceLimits const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- , maxComputeWorkGroupCount{}
- , maxComputeWorkGroupInvocations( rhs.maxComputeWorkGroupInvocations )
- , maxComputeWorkGroupSize{}
- , subPixelPrecisionBits( rhs.subPixelPrecisionBits )
- , subTexelPrecisionBits( rhs.subTexelPrecisionBits )
- , mipmapPrecisionBits( rhs.mipmapPrecisionBits )
- , maxDrawIndexedIndexValue( rhs.maxDrawIndexedIndexValue )
- , maxDrawIndirectCount( rhs.maxDrawIndirectCount )
- , maxSamplerLodBias( rhs.maxSamplerLodBias )
- , maxSamplerAnisotropy( rhs.maxSamplerAnisotropy )
- , maxViewports( rhs.maxViewports )
- , maxViewportDimensions{}
- , viewportBoundsRange{}
- , 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 )
- , pointSizeRange{}
- , lineWidthRange{}
- , pointSizeGranularity( rhs.pointSizeGranularity )
- , lineWidthGranularity( rhs.lineWidthGranularity )
- , strictLines( rhs.strictLines )
- , standardSampleLocations( rhs.standardSampleLocations )
- , optimalBufferCopyOffsetAlignment( rhs.optimalBufferCopyOffsetAlignment )
- , optimalBufferCopyRowPitchAlignment( rhs.optimalBufferCopyRowPitchAlignment )
- , nonCoherentAtomSize( rhs.nonCoherentAtomSize )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,2>::copy( maxViewportDimensions, rhs.maxViewportDimensions );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( viewportBoundsRange, rhs.viewportBoundsRange );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( pointSizeRange, rhs.pointSizeRange );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( lineWidthRange, rhs.lineWidthRange );
- }
-
- PhysicalDeviceLimits & operator=( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PhysicalDeviceLimits ) );
- return *this;
- }
+ {}
PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
{
&& ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
&& ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
&& ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
- && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount )
&& ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
- && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize )
&& ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
&& ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
&& ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
&& ( 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 )
+ && ( maxViewportDimensions == rhs.maxViewportDimensions )
+ && ( viewportBoundsRange == rhs.viewportBoundsRange )
&& ( viewportSubPixelBits == rhs.viewportSubPixelBits )
&& ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
&& ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
&& ( 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 )
+ && ( pointSizeRange == rhs.pointSizeRange )
+ && ( lineWidthRange == rhs.lineWidthRange )
&& ( pointSizeGranularity == rhs.pointSizeGranularity )
&& ( lineWidthGranularity == rhs.lineWidthGranularity )
&& ( strictLines == rhs.strictLines )
uint32_t maxFragmentDualSrcAttachments = {};
uint32_t maxFragmentCombinedOutputResources = {};
uint32_t maxComputeSharedMemorySize = {};
- uint32_t maxComputeWorkGroupCount[3] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxComputeWorkGroupCount = {};
uint32_t maxComputeWorkGroupInvocations = {};
- uint32_t maxComputeWorkGroupSize[3] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxComputeWorkGroupSize = {};
uint32_t subPixelPrecisionBits = {};
uint32_t subTexelPrecisionBits = {};
uint32_t mipmapPrecisionBits = {};
float maxSamplerLodBias = {};
float maxSamplerAnisotropy = {};
uint32_t maxViewports = {};
- uint32_t maxViewportDimensions[2] = {};
- float viewportBoundsRange[2] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 2> maxViewportDimensions = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> viewportBoundsRange = {};
uint32_t viewportSubPixelBits = {};
size_t minMemoryMapAlignment = {};
VULKAN_HPP_NAMESPACE::DeviceSize minTexelBufferOffsetAlignment = {};
uint32_t maxCullDistances = {};
uint32_t maxCombinedClipAndCullDistances = {};
uint32_t discreteQueuePriorities = {};
- float pointSizeRange[2] = {};
- float lineWidthRange[2] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> pointSizeRange = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> lineWidthRange = {};
float pointSizeGranularity = {};
float lineWidthGranularity = {};
VULKAN_HPP_NAMESPACE::Bool32 strictLines = {};
, stippledSmoothLines( stippledSmoothLines_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , rectangularLines( rhs.rectangularLines )
- , bresenhamLines( rhs.bresenhamLines )
- , smoothLines( rhs.smoothLines )
- , stippledRectangularLines( rhs.stippledRectangularLines )
- , stippledBresenhamLines( rhs.stippledBresenhamLines )
- , stippledSmoothLines( rhs.stippledSmoothLines )
- {}
-
PhysicalDeviceLineRasterizationFeaturesEXT & operator=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) - offsetof( PhysicalDeviceLineRasterizationFeaturesEXT, pNext ) );
: lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , lineSubPixelPrecisionBits( rhs.lineSubPixelPrecisionBits )
- {}
-
PhysicalDeviceLineRasterizationPropertiesEXT & operator=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) - offsetof( PhysicalDeviceLineRasterizationPropertiesEXT, pNext ) );
, maxMemoryAllocationSize( maxMemoryAllocationSize_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( PhysicalDeviceMaintenance3Properties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxPerSetDescriptors( rhs.maxPerSetDescriptors )
- , maxMemoryAllocationSize( rhs.maxMemoryAllocationSize )
- {}
-
PhysicalDeviceMaintenance3Properties & operator=( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMaintenance3Properties ) - offsetof( PhysicalDeviceMaintenance3Properties, pNext ) );
{
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( std::array<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapBudget_ = {},
std::array<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapUsage_ = {} ) VULKAN_HPP_NOEXCEPT
- : heapBudget{}
- , heapUsage{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS>::copy( heapBudget, heapBudget_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS>::copy( heapUsage, heapUsage_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , heapBudget{}
- , heapUsage{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS>::copy( heapBudget, rhs.heapBudget );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS>::copy( heapUsage, rhs.heapUsage );
- }
+ : heapBudget( heapBudget_ )
+ , heapUsage( heapUsage_ )
+ {}
PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( VULKAN_HPP_NAMESPACE::DeviceSize ) ) == 0 )
- && ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( VULKAN_HPP_NAMESPACE::DeviceSize ) ) == 0 );
+ && ( heapBudget == rhs.heapBudget )
+ && ( heapUsage == rhs.heapUsage );
}
bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
void* pNext = {};
- VULKAN_HPP_NAMESPACE::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS] = {};
- VULKAN_HPP_NAMESPACE::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> heapBudget = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> heapUsage = {};
};
static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceMemoryBudgetPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
: memoryPriority( memoryPriority_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( PhysicalDeviceMemoryPriorityFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryPriority( rhs.memoryPriority )
- {}
-
PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) - offsetof( PhysicalDeviceMemoryPriorityFeaturesEXT, pNext ) );
uint32_t memoryHeapCount_ = {},
std::array<VULKAN_HPP_NAMESPACE::MemoryHeap,VK_MAX_MEMORY_HEAPS> const& memoryHeaps_ = {} ) VULKAN_HPP_NOEXCEPT
: memoryTypeCount( memoryTypeCount_ )
- , memoryTypes{}
+ , memoryTypes( memoryTypes_ )
, memoryHeapCount( memoryHeapCount_ )
- , memoryHeaps{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::MemoryType,VK_MAX_MEMORY_TYPES>::copy( memoryTypes, memoryTypes_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::MemoryHeap,VK_MAX_MEMORY_HEAPS>::copy( memoryHeaps, memoryHeaps_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( PhysicalDeviceMemoryProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : memoryTypeCount( rhs.memoryTypeCount )
- , memoryTypes{}
- , memoryHeapCount( rhs.memoryHeapCount )
- , memoryHeaps{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::MemoryType,VK_MAX_MEMORY_TYPES>::copy( memoryTypes, rhs.memoryTypes );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<VULKAN_HPP_NAMESPACE::MemoryHeap,VK_MAX_MEMORY_HEAPS>::copy( memoryHeaps, rhs.memoryHeaps );
- }
-
- PhysicalDeviceMemoryProperties & operator=( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PhysicalDeviceMemoryProperties ) );
- return *this;
- }
+ , memoryHeaps( memoryHeaps_ )
+ {}
PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( memoryTypeCount == rhs.memoryTypeCount )
- && ( memcmp( memoryTypes, rhs.memoryTypes, std::min<uint32_t>( VK_MAX_MEMORY_TYPES, memoryTypeCount ) * sizeof( VULKAN_HPP_NAMESPACE::MemoryType ) ) == 0 )
+ && ( memoryTypes == rhs.memoryTypes )
&& ( memoryHeapCount == rhs.memoryHeapCount )
- && ( memcmp( memoryHeaps, rhs.memoryHeaps, std::min<uint32_t>( VK_MAX_MEMORY_HEAPS, memoryHeapCount ) * sizeof( VULKAN_HPP_NAMESPACE::MemoryHeap ) ) == 0 );
+ && ( memoryHeaps == rhs.memoryHeaps );
}
bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
public:
uint32_t memoryTypeCount = {};
- VULKAN_HPP_NAMESPACE::MemoryType memoryTypes[VK_MAX_MEMORY_TYPES] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryType, VK_MAX_MEMORY_TYPES> memoryTypes = {};
uint32_t memoryHeapCount = {};
- VULKAN_HPP_NAMESPACE::MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryHeap, VK_MAX_MEMORY_HEAPS> memoryHeaps = {};
};
static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties>::value, "struct wrapper is not a standard layout!" );
: memoryProperties( memoryProperties_ )
{}
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( PhysicalDeviceMemoryProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryProperties( rhs.memoryProperties )
- {}
-
PhysicalDeviceMemoryProperties2 & operator=( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMemoryProperties2 ) - offsetof( PhysicalDeviceMemoryProperties2, pNext ) );
, meshShader( meshShader_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , taskShader( rhs.taskShader )
- , meshShader( rhs.meshShader )
- {}
-
PhysicalDeviceMeshShaderFeaturesNV & operator=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) - offsetof( PhysicalDeviceMeshShaderFeaturesNV, pNext ) );
uint32_t meshOutputPerPrimitiveGranularity_ = {} ) VULKAN_HPP_NOEXCEPT
: maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
, maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
- , maxTaskWorkGroupSize{}
+ , maxTaskWorkGroupSize( maxTaskWorkGroupSize_ )
, maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
, maxTaskOutputCount( maxTaskOutputCount_ )
, maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
- , maxMeshWorkGroupSize{}
+ , maxMeshWorkGroupSize( maxMeshWorkGroupSize_ )
, maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
, maxMeshOutputVertices( maxMeshOutputVertices_ )
, maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
, maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
, meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
, meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxTaskWorkGroupSize, maxTaskWorkGroupSize_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxMeshWorkGroupSize, maxMeshWorkGroupSize_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxDrawMeshTasksCount( rhs.maxDrawMeshTasksCount )
- , maxTaskWorkGroupInvocations( rhs.maxTaskWorkGroupInvocations )
- , maxTaskWorkGroupSize{}
- , maxTaskTotalMemorySize( rhs.maxTaskTotalMemorySize )
- , maxTaskOutputCount( rhs.maxTaskOutputCount )
- , maxMeshWorkGroupInvocations( rhs.maxMeshWorkGroupInvocations )
- , maxMeshWorkGroupSize{}
- , maxMeshTotalMemorySize( rhs.maxMeshTotalMemorySize )
- , maxMeshOutputVertices( rhs.maxMeshOutputVertices )
- , maxMeshOutputPrimitives( rhs.maxMeshOutputPrimitives )
- , maxMeshMultiviewViewCount( rhs.maxMeshMultiviewViewCount )
- , meshOutputPerVertexGranularity( rhs.meshOutputPerVertexGranularity )
- , meshOutputPerPrimitiveGranularity( rhs.meshOutputPerPrimitiveGranularity )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize );
- }
+ {}
PhysicalDeviceMeshShaderPropertiesNV & operator=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
&& ( pNext == rhs.pNext )
&& ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount )
&& ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations )
- && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize )
&& ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize )
&& ( maxTaskOutputCount == rhs.maxTaskOutputCount )
&& ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations )
- && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize )
&& ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize )
&& ( maxMeshOutputVertices == rhs.maxMeshOutputVertices )
&& ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives )
void* pNext = {};
uint32_t maxDrawMeshTasksCount = {};
uint32_t maxTaskWorkGroupInvocations = {};
- uint32_t maxTaskWorkGroupSize[3] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxTaskWorkGroupSize = {};
uint32_t maxTaskTotalMemorySize = {};
uint32_t maxTaskOutputCount = {};
uint32_t maxMeshWorkGroupInvocations = {};
- uint32_t maxMeshWorkGroupSize[3] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxMeshWorkGroupSize = {};
uint32_t maxMeshTotalMemorySize = {};
uint32_t maxMeshOutputVertices = {};
uint32_t maxMeshOutputPrimitives = {};
, multiviewTessellationShader( multiviewTessellationShader_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( PhysicalDeviceMultiviewFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , multiview( rhs.multiview )
- , multiviewGeometryShader( rhs.multiviewGeometryShader )
- , multiviewTessellationShader( rhs.multiviewTessellationShader )
- {}
-
PhysicalDeviceMultiviewFeatures & operator=( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMultiviewFeatures ) - offsetof( PhysicalDeviceMultiviewFeatures, pNext ) );
: perViewPositionAllComponents( perViewPositionAllComponents_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , perViewPositionAllComponents( rhs.perViewPositionAllComponents )
- {}
-
PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) - offsetof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext ) );
, maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( PhysicalDeviceMultiviewProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxMultiviewViewCount( rhs.maxMultiviewViewCount )
- , maxMultiviewInstanceIndex( rhs.maxMultiviewInstanceIndex )
- {}
-
PhysicalDeviceMultiviewProperties & operator=( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceMultiviewProperties ) - offsetof( PhysicalDeviceMultiviewProperties, pNext ) );
, pciFunction( pciFunction_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pciDomain( rhs.pciDomain )
- , pciBus( rhs.pciBus )
- , pciDevice( rhs.pciDevice )
- , pciFunction( rhs.pciFunction )
- {}
-
PhysicalDevicePCIBusInfoPropertiesEXT & operator=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) - offsetof( PhysicalDevicePCIBusInfoPropertiesEXT, pNext ) );
, performanceCounterMultipleQueryPools( performanceCounterMultipleQueryPools_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( PhysicalDevicePerformanceQueryFeaturesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , performanceCounterQueryPools( rhs.performanceCounterQueryPools )
- , performanceCounterMultipleQueryPools( rhs.performanceCounterMultipleQueryPools )
- {}
-
PhysicalDevicePerformanceQueryFeaturesKHR & operator=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) - offsetof( PhysicalDevicePerformanceQueryFeaturesKHR, pNext ) );
: allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( PhysicalDevicePerformanceQueryPropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , allowCommandBufferQueryCopies( rhs.allowCommandBufferQueryCopies )
- {}
-
PhysicalDevicePerformanceQueryPropertiesKHR & operator=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) - offsetof( PhysicalDevicePerformanceQueryPropertiesKHR, pNext ) );
: pipelineCreationCacheControl( pipelineCreationCacheControl_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeaturesEXT( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pipelineCreationCacheControl( rhs.pipelineCreationCacheControl )
- {}
-
PhysicalDevicePipelineCreationCacheControlFeaturesEXT & operator=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT ) - offsetof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT, pNext ) );
: pipelineExecutableInfo( pipelineExecutableInfo_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pipelineExecutableInfo( rhs.pipelineExecutableInfo )
- {}
-
PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) - offsetof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, pNext ) );
: pointClippingBehavior( pointClippingBehavior_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( PhysicalDevicePointClippingProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pointClippingBehavior( rhs.pointClippingBehavior )
- {}
-
PhysicalDevicePointClippingProperties & operator=( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePointClippingProperties ) - offsetof( PhysicalDevicePointClippingProperties, pNext ) );
, residencyNonResidentStrict( residencyNonResidentStrict_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( PhysicalDeviceSparseProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : residencyStandard2DBlockShape( rhs.residencyStandard2DBlockShape )
- , residencyStandard2DMultisampleBlockShape( rhs.residencyStandard2DMultisampleBlockShape )
- , residencyStandard3DBlockShape( rhs.residencyStandard3DBlockShape )
- , residencyAlignedMipSize( rhs.residencyAlignedMipSize )
- , residencyNonResidentStrict( rhs.residencyNonResidentStrict )
- {}
-
- PhysicalDeviceSparseProperties & operator=( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PhysicalDeviceSparseProperties ) );
- return *this;
- }
-
PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, vendorID( vendorID_ )
, deviceID( deviceID_ )
, deviceType( deviceType_ )
- , deviceName{}
- , pipelineCacheUUID{}
+ , deviceName( deviceName_ )
+ , pipelineCacheUUID( pipelineCacheUUID_ )
, limits( limits_ )
, sparseProperties( sparseProperties_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE>::copy( deviceName, deviceName_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( pipelineCacheUUID, pipelineCacheUUID_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( PhysicalDeviceProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : apiVersion( rhs.apiVersion )
- , driverVersion( rhs.driverVersion )
- , vendorID( rhs.vendorID )
- , deviceID( rhs.deviceID )
- , deviceType( rhs.deviceType )
- , deviceName{}
- , pipelineCacheUUID{}
- , limits( rhs.limits )
- , sparseProperties( rhs.sparseProperties )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE>::copy( deviceName, rhs.deviceName );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( pipelineCacheUUID, rhs.pipelineCacheUUID );
- }
-
- PhysicalDeviceProperties & operator=( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PhysicalDeviceProperties ) );
- return *this;
- }
+ {}
PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
&& ( 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 )
+ && ( deviceName == rhs.deviceName )
+ && ( pipelineCacheUUID == rhs.pipelineCacheUUID )
&& ( limits == rhs.limits )
&& ( sparseProperties == rhs.sparseProperties );
}
uint32_t vendorID = {};
uint32_t deviceID = {};
VULKAN_HPP_NAMESPACE::PhysicalDeviceType deviceType = VULKAN_HPP_NAMESPACE::PhysicalDeviceType::eOther;
- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] = {};
- uint8_t pipelineCacheUUID[VK_UUID_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE> deviceName = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> pipelineCacheUUID = {};
VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits limits = {};
VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties sparseProperties = {};
};
: properties( properties_ )
{}
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( PhysicalDeviceProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , properties( rhs.properties )
- {}
-
PhysicalDeviceProperties2 & operator=( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceProperties2 ) - offsetof( PhysicalDeviceProperties2, pNext ) );
: protectedMemory( protectedMemory_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( PhysicalDeviceProtectedMemoryFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , protectedMemory( rhs.protectedMemory )
- {}
-
PhysicalDeviceProtectedMemoryFeatures & operator=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceProtectedMemoryFeatures ) - offsetof( PhysicalDeviceProtectedMemoryFeatures, pNext ) );
: protectedNoFault( protectedNoFault_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( PhysicalDeviceProtectedMemoryProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , protectedNoFault( rhs.protectedNoFault )
- {}
-
PhysicalDeviceProtectedMemoryProperties & operator=( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceProtectedMemoryProperties ) - offsetof( PhysicalDeviceProtectedMemoryProperties, pNext ) );
: maxPushDescriptors( maxPushDescriptors_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorPropertiesKHR( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxPushDescriptors( rhs.maxPushDescriptors )
- {}
-
PhysicalDevicePushDescriptorPropertiesKHR & operator=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) - offsetof( PhysicalDevicePushDescriptorPropertiesKHR, pNext ) );
, rayTracingPrimitiveCulling( rayTracingPrimitiveCulling_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingFeaturesKHR( PhysicalDeviceRayTracingFeaturesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , rayTracing( rhs.rayTracing )
- , rayTracingShaderGroupHandleCaptureReplay( rhs.rayTracingShaderGroupHandleCaptureReplay )
- , rayTracingShaderGroupHandleCaptureReplayMixed( rhs.rayTracingShaderGroupHandleCaptureReplayMixed )
- , rayTracingAccelerationStructureCaptureReplay( rhs.rayTracingAccelerationStructureCaptureReplay )
- , rayTracingIndirectTraceRays( rhs.rayTracingIndirectTraceRays )
- , rayTracingIndirectAccelerationStructureBuild( rhs.rayTracingIndirectAccelerationStructureBuild )
- , rayTracingHostAccelerationStructureCommands( rhs.rayTracingHostAccelerationStructureCommands )
- , rayQuery( rhs.rayQuery )
- , rayTracingPrimitiveCulling( rhs.rayTracingPrimitiveCulling )
- {}
-
PhysicalDeviceRayTracingFeaturesKHR & operator=( PhysicalDeviceRayTracingFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRayTracingFeaturesKHR ) - offsetof( PhysicalDeviceRayTracingFeaturesKHR, pNext ) );
, shaderGroupHandleCaptureReplaySize( shaderGroupHandleCaptureReplaySize_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesKHR( PhysicalDeviceRayTracingPropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderGroupHandleSize( rhs.shaderGroupHandleSize )
- , maxRecursionDepth( rhs.maxRecursionDepth )
- , maxShaderGroupStride( rhs.maxShaderGroupStride )
- , shaderGroupBaseAlignment( rhs.shaderGroupBaseAlignment )
- , maxGeometryCount( rhs.maxGeometryCount )
- , maxInstanceCount( rhs.maxInstanceCount )
- , maxPrimitiveCount( rhs.maxPrimitiveCount )
- , maxDescriptorSetAccelerationStructures( rhs.maxDescriptorSetAccelerationStructures )
- , shaderGroupHandleCaptureReplaySize( rhs.shaderGroupHandleCaptureReplaySize )
- {}
-
PhysicalDeviceRayTracingPropertiesKHR & operator=( PhysicalDeviceRayTracingPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRayTracingPropertiesKHR ) - offsetof( PhysicalDeviceRayTracingPropertiesKHR, pNext ) );
, maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( PhysicalDeviceRayTracingPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderGroupHandleSize( rhs.shaderGroupHandleSize )
- , maxRecursionDepth( rhs.maxRecursionDepth )
- , maxShaderGroupStride( rhs.maxShaderGroupStride )
- , shaderGroupBaseAlignment( rhs.shaderGroupBaseAlignment )
- , maxGeometryCount( rhs.maxGeometryCount )
- , maxInstanceCount( rhs.maxInstanceCount )
- , maxTriangleCount( rhs.maxTriangleCount )
- , maxDescriptorSetAccelerationStructures( rhs.maxDescriptorSetAccelerationStructures )
- {}
-
PhysicalDeviceRayTracingPropertiesNV & operator=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRayTracingPropertiesNV ) - offsetof( PhysicalDeviceRayTracingPropertiesNV, pNext ) );
: representativeFragmentTest( representativeFragmentTest_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , representativeFragmentTest( rhs.representativeFragmentTest )
- {}
-
PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) - offsetof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV, pNext ) );
VULKAN_HPP_NAMESPACE::Bool32 variableSampleLocations_ = {} ) VULKAN_HPP_NOEXCEPT
: sampleLocationSampleCounts( sampleLocationSampleCounts_ )
, maxSampleLocationGridSize( maxSampleLocationGridSize_ )
- , sampleLocationCoordinateRange{}
+ , sampleLocationCoordinateRange( sampleLocationCoordinateRange_ )
, sampleLocationSubPixelBits( sampleLocationSubPixelBits_ )
, variableSampleLocations( variableSampleLocations_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( sampleLocationCoordinateRange, sampleLocationCoordinateRange_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , sampleLocationSampleCounts( rhs.sampleLocationSampleCounts )
- , maxSampleLocationGridSize( rhs.maxSampleLocationGridSize )
- , sampleLocationCoordinateRange{}
- , sampleLocationSubPixelBits( rhs.sampleLocationSubPixelBits )
- , variableSampleLocations( rhs.variableSampleLocations )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,2>::copy( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange );
- }
+ {}
PhysicalDeviceSampleLocationsPropertiesEXT & operator=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
&& ( pNext == rhs.pNext )
&& ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts )
&& ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize )
- && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 )
+ && ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange )
&& ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits )
&& ( variableSampleLocations == rhs.variableSampleLocations );
}
void* pNext = {};
VULKAN_HPP_NAMESPACE::SampleCountFlags sampleLocationSampleCounts = {};
VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize = {};
- float sampleLocationCoordinateRange[2] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> sampleLocationCoordinateRange = {};
uint32_t sampleLocationSubPixelBits = {};
VULKAN_HPP_NAMESPACE::Bool32 variableSampleLocations = {};
};
, filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( PhysicalDeviceSamplerFilterMinmaxProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , filterMinmaxSingleComponentFormats( rhs.filterMinmaxSingleComponentFormats )
- , filterMinmaxImageComponentMapping( rhs.filterMinmaxImageComponentMapping )
- {}
-
PhysicalDeviceSamplerFilterMinmaxProperties & operator=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSamplerFilterMinmaxProperties ) - offsetof( PhysicalDeviceSamplerFilterMinmaxProperties, pNext ) );
: samplerYcbcrConversion( samplerYcbcrConversion_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , samplerYcbcrConversion( rhs.samplerYcbcrConversion )
- {}
-
PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) - offsetof( PhysicalDeviceSamplerYcbcrConversionFeatures, pNext ) );
: scalarBlockLayout( scalarBlockLayout_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( PhysicalDeviceScalarBlockLayoutFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , scalarBlockLayout( rhs.scalarBlockLayout )
- {}
-
PhysicalDeviceScalarBlockLayoutFeatures & operator=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceScalarBlockLayoutFeatures ) - offsetof( PhysicalDeviceScalarBlockLayoutFeatures, pNext ) );
: separateDepthStencilLayouts( separateDepthStencilLayouts_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , separateDepthStencilLayouts( rhs.separateDepthStencilLayouts )
- {}
-
PhysicalDeviceSeparateDepthStencilLayoutsFeatures & operator=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) - offsetof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures, pNext ) );
, shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( PhysicalDeviceShaderAtomicInt64Features const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderBufferInt64Atomics( rhs.shaderBufferInt64Atomics )
- , shaderSharedInt64Atomics( rhs.shaderSharedInt64Atomics )
- {}
-
PhysicalDeviceShaderAtomicInt64Features & operator=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderAtomicInt64Features ) - offsetof( PhysicalDeviceShaderAtomicInt64Features, pNext ) );
, shaderDeviceClock( shaderDeviceClock_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( PhysicalDeviceShaderClockFeaturesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderSubgroupClock( rhs.shaderSubgroupClock )
- , shaderDeviceClock( rhs.shaderDeviceClock )
- {}
-
PhysicalDeviceShaderClockFeaturesKHR & operator=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderClockFeaturesKHR ) - offsetof( PhysicalDeviceShaderClockFeaturesKHR, pNext ) );
, activeComputeUnitCount( activeComputeUnitCount_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderCoreFeatures( rhs.shaderCoreFeatures )
- , activeComputeUnitCount( rhs.activeComputeUnitCount )
- {}
-
PhysicalDeviceShaderCoreProperties2AMD & operator=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderCoreProperties2AMD ) - offsetof( PhysicalDeviceShaderCoreProperties2AMD, pNext ) );
, vgprAllocationGranularity( vgprAllocationGranularity_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderEngineCount( rhs.shaderEngineCount )
- , shaderArraysPerEngineCount( rhs.shaderArraysPerEngineCount )
- , computeUnitsPerShaderArray( rhs.computeUnitsPerShaderArray )
- , simdPerComputeUnit( rhs.simdPerComputeUnit )
- , wavefrontsPerSimd( rhs.wavefrontsPerSimd )
- , wavefrontSize( rhs.wavefrontSize )
- , sgprsPerSimd( rhs.sgprsPerSimd )
- , minSgprAllocation( rhs.minSgprAllocation )
- , maxSgprAllocation( rhs.maxSgprAllocation )
- , sgprAllocationGranularity( rhs.sgprAllocationGranularity )
- , vgprsPerSimd( rhs.vgprsPerSimd )
- , minVgprAllocation( rhs.minVgprAllocation )
- , maxVgprAllocation( rhs.maxVgprAllocation )
- , vgprAllocationGranularity( rhs.vgprAllocationGranularity )
- {}
-
PhysicalDeviceShaderCorePropertiesAMD & operator=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderCorePropertiesAMD ) - offsetof( PhysicalDeviceShaderCorePropertiesAMD, pNext ) );
: shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderDemoteToHelperInvocation( rhs.shaderDemoteToHelperInvocation )
- {}
-
PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & operator=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) - offsetof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, pNext ) );
: shaderDrawParameters( shaderDrawParameters_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( PhysicalDeviceShaderDrawParametersFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderDrawParameters( rhs.shaderDrawParameters )
- {}
-
PhysicalDeviceShaderDrawParametersFeatures & operator=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderDrawParametersFeatures ) - offsetof( PhysicalDeviceShaderDrawParametersFeatures, pNext ) );
, shaderInt8( shaderInt8_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( PhysicalDeviceShaderFloat16Int8Features const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderFloat16( rhs.shaderFloat16 )
- , shaderInt8( rhs.shaderInt8 )
- {}
-
PhysicalDeviceShaderFloat16Int8Features & operator=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderFloat16Int8Features ) - offsetof( PhysicalDeviceShaderFloat16Int8Features, pNext ) );
: imageFootprint( imageFootprint_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , imageFootprint( rhs.imageFootprint )
- {}
-
PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) - offsetof( PhysicalDeviceShaderImageFootprintFeaturesNV, pNext ) );
: shaderIntegerFunctions2( shaderIntegerFunctions2_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderIntegerFunctions2( rhs.shaderIntegerFunctions2 )
- {}
-
PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) - offsetof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, pNext ) );
: shaderSMBuiltins( shaderSMBuiltins_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( PhysicalDeviceShaderSMBuiltinsFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderSMBuiltins( rhs.shaderSMBuiltins )
- {}
-
PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) - offsetof( PhysicalDeviceShaderSMBuiltinsFeaturesNV, pNext ) );
, shaderWarpsPerSM( shaderWarpsPerSM_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( PhysicalDeviceShaderSMBuiltinsPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderSMCount( rhs.shaderSMCount )
- , shaderWarpsPerSM( rhs.shaderWarpsPerSM )
- {}
-
PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) - offsetof( PhysicalDeviceShaderSMBuiltinsPropertiesNV, pNext ) );
: shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shaderSubgroupExtendedTypes( rhs.shaderSubgroupExtendedTypes )
- {}
-
PhysicalDeviceShaderSubgroupExtendedTypesFeatures & operator=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) - offsetof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures, pNext ) );
, shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shadingRateImage( rhs.shadingRateImage )
- , shadingRateCoarseSampleOrder( rhs.shadingRateCoarseSampleOrder )
- {}
-
PhysicalDeviceShadingRateImageFeaturesNV & operator=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) - offsetof( PhysicalDeviceShadingRateImageFeaturesNV, pNext ) );
, shadingRateMaxCoarseSamples( shadingRateMaxCoarseSamples_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shadingRateTexelSize( rhs.shadingRateTexelSize )
- , shadingRatePaletteSize( rhs.shadingRatePaletteSize )
- , shadingRateMaxCoarseSamples( rhs.shadingRateMaxCoarseSamples )
- {}
-
PhysicalDeviceShadingRateImagePropertiesNV & operator=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) - offsetof( PhysicalDeviceShadingRateImagePropertiesNV, pNext ) );
, tiling( tiling_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , format( rhs.format )
- , type( rhs.type )
- , samples( rhs.samples )
- , usage( rhs.usage )
- , tiling( rhs.tiling )
- {}
-
PhysicalDeviceSparseImageFormatInfo2 & operator=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) - offsetof( PhysicalDeviceSparseImageFormatInfo2, pNext ) );
, quadOperationsInAllStages( quadOperationsInAllStages_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( PhysicalDeviceSubgroupProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , subgroupSize( rhs.subgroupSize )
- , supportedStages( rhs.supportedStages )
- , supportedOperations( rhs.supportedOperations )
- , quadOperationsInAllStages( rhs.quadOperationsInAllStages )
- {}
-
PhysicalDeviceSubgroupProperties & operator=( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSubgroupProperties ) - offsetof( PhysicalDeviceSubgroupProperties, pNext ) );
, computeFullSubgroups( computeFullSubgroups_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , subgroupSizeControl( rhs.subgroupSizeControl )
- , computeFullSubgroups( rhs.computeFullSubgroups )
- {}
-
PhysicalDeviceSubgroupSizeControlFeaturesEXT & operator=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) - offsetof( PhysicalDeviceSubgroupSizeControlFeaturesEXT, pNext ) );
, requiredSubgroupSizeStages( requiredSubgroupSizeStages_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlPropertiesEXT( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , minSubgroupSize( rhs.minSubgroupSize )
- , maxSubgroupSize( rhs.maxSubgroupSize )
- , maxComputeWorkgroupSubgroups( rhs.maxComputeWorkgroupSubgroups )
- , requiredSubgroupSizeStages( rhs.requiredSubgroupSizeStages )
- {}
-
PhysicalDeviceSubgroupSizeControlPropertiesEXT & operator=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) - offsetof( PhysicalDeviceSubgroupSizeControlPropertiesEXT, pNext ) );
: surface( surface_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( PhysicalDeviceSurfaceInfo2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , surface( rhs.surface )
- {}
-
PhysicalDeviceSurfaceInfo2KHR & operator=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceSurfaceInfo2KHR ) - offsetof( PhysicalDeviceSurfaceInfo2KHR, pNext ) );
: texelBufferAlignment( texelBufferAlignment_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , texelBufferAlignment( rhs.texelBufferAlignment )
- {}
-
PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) - offsetof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT, pNext ) );
, uniformTexelBufferOffsetSingleTexelAlignment( uniformTexelBufferOffsetSingleTexelAlignment_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentPropertiesEXT( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , storageTexelBufferOffsetAlignmentBytes( rhs.storageTexelBufferOffsetAlignmentBytes )
- , storageTexelBufferOffsetSingleTexelAlignment( rhs.storageTexelBufferOffsetSingleTexelAlignment )
- , uniformTexelBufferOffsetAlignmentBytes( rhs.uniformTexelBufferOffsetAlignmentBytes )
- , uniformTexelBufferOffsetSingleTexelAlignment( rhs.uniformTexelBufferOffsetSingleTexelAlignment )
- {}
-
PhysicalDeviceTexelBufferAlignmentPropertiesEXT & operator=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) - offsetof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT, pNext ) );
: textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , textureCompressionASTC_HDR( rhs.textureCompressionASTC_HDR )
- {}
-
PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) - offsetof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, pNext ) );
: timelineSemaphore( timelineSemaphore_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( PhysicalDeviceTimelineSemaphoreFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , timelineSemaphore( rhs.timelineSemaphore )
- {}
-
PhysicalDeviceTimelineSemaphoreFeatures & operator=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTimelineSemaphoreFeatures ) - offsetof( PhysicalDeviceTimelineSemaphoreFeatures, pNext ) );
: maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( PhysicalDeviceTimelineSemaphoreProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxTimelineSemaphoreValueDifference( rhs.maxTimelineSemaphoreValueDifference )
- {}
-
PhysicalDeviceTimelineSemaphoreProperties & operator=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTimelineSemaphoreProperties ) - offsetof( PhysicalDeviceTimelineSemaphoreProperties, pNext ) );
VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT purposes_ = {},
std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {},
std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& layer_ = {} ) VULKAN_HPP_NOEXCEPT
- : name{}
- , version{}
+ : name( name_ )
+ , version( version_ )
, purposes( purposes_ )
- , description{}
- , layer{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( name, name_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( version, version_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( layer, layer_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolPropertiesEXT( PhysicalDeviceToolPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , name{}
- , version{}
- , purposes( rhs.purposes )
- , description{}
- , layer{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( name, rhs.name );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( version, rhs.version );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, rhs.description );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE>::copy( layer, rhs.layer );
- }
+ , description( description_ )
+ , layer( layer_ )
+ {}
PhysicalDeviceToolPropertiesEXT & operator=( PhysicalDeviceToolPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memcmp( name, rhs.name, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( version, rhs.version, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
+ && ( name == rhs.name )
+ && ( version == rhs.version )
&& ( purposes == rhs.purposes )
- && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( layer, rhs.layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 );
+ && ( description == rhs.description )
+ && ( layer == rhs.layer );
}
bool operator!=( PhysicalDeviceToolPropertiesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceToolPropertiesEXT;
void* pNext = {};
- char name[VK_MAX_EXTENSION_NAME_SIZE] = {};
- char version[VK_MAX_EXTENSION_NAME_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> name = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> version = {};
VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT purposes = {};
- char description[VK_MAX_DESCRIPTION_SIZE] = {};
- char layer[VK_MAX_EXTENSION_NAME_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> layer = {};
};
static_assert( sizeof( PhysicalDeviceToolPropertiesEXT ) == sizeof( VkPhysicalDeviceToolPropertiesEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceToolPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
, geometryStreams( geometryStreams_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , transformFeedback( rhs.transformFeedback )
- , geometryStreams( rhs.geometryStreams )
- {}
-
PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) - offsetof( PhysicalDeviceTransformFeedbackFeaturesEXT, pNext ) );
, transformFeedbackDraw( transformFeedbackDraw_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxTransformFeedbackStreams( rhs.maxTransformFeedbackStreams )
- , maxTransformFeedbackBuffers( rhs.maxTransformFeedbackBuffers )
- , maxTransformFeedbackBufferSize( rhs.maxTransformFeedbackBufferSize )
- , maxTransformFeedbackStreamDataSize( rhs.maxTransformFeedbackStreamDataSize )
- , maxTransformFeedbackBufferDataSize( rhs.maxTransformFeedbackBufferDataSize )
- , maxTransformFeedbackBufferDataStride( rhs.maxTransformFeedbackBufferDataStride )
- , transformFeedbackQueries( rhs.transformFeedbackQueries )
- , transformFeedbackStreamsLinesTriangles( rhs.transformFeedbackStreamsLinesTriangles )
- , transformFeedbackRasterizationStreamSelect( rhs.transformFeedbackRasterizationStreamSelect )
- , transformFeedbackDraw( rhs.transformFeedbackDraw )
- {}
-
PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) - offsetof( PhysicalDeviceTransformFeedbackPropertiesEXT, pNext ) );
: uniformBufferStandardLayout( uniformBufferStandardLayout_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( PhysicalDeviceUniformBufferStandardLayoutFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , uniformBufferStandardLayout( rhs.uniformBufferStandardLayout )
- {}
-
PhysicalDeviceUniformBufferStandardLayoutFeatures & operator=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceUniformBufferStandardLayoutFeatures ) - offsetof( PhysicalDeviceUniformBufferStandardLayoutFeatures, pNext ) );
, variablePointers( variablePointers_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( PhysicalDeviceVariablePointersFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , variablePointersStorageBuffer( rhs.variablePointersStorageBuffer )
- , variablePointers( rhs.variablePointers )
- {}
-
PhysicalDeviceVariablePointersFeatures & operator=( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceVariablePointersFeatures ) - offsetof( PhysicalDeviceVariablePointersFeatures, pNext ) );
, vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , vertexAttributeInstanceRateDivisor( rhs.vertexAttributeInstanceRateDivisor )
- , vertexAttributeInstanceRateZeroDivisor( rhs.vertexAttributeInstanceRateZeroDivisor )
- {}
-
PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) - offsetof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT, pNext ) );
: maxVertexAttribDivisor( maxVertexAttribDivisor_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxVertexAttribDivisor( rhs.maxVertexAttribDivisor )
- {}
-
PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) - offsetof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT, pNext ) );
, shaderDrawParameters( shaderDrawParameters_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( PhysicalDeviceVulkan11Features const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , storageBuffer16BitAccess( rhs.storageBuffer16BitAccess )
- , uniformAndStorageBuffer16BitAccess( rhs.uniformAndStorageBuffer16BitAccess )
- , storagePushConstant16( rhs.storagePushConstant16 )
- , storageInputOutput16( rhs.storageInputOutput16 )
- , multiview( rhs.multiview )
- , multiviewGeometryShader( rhs.multiviewGeometryShader )
- , multiviewTessellationShader( rhs.multiviewTessellationShader )
- , variablePointersStorageBuffer( rhs.variablePointersStorageBuffer )
- , variablePointers( rhs.variablePointers )
- , protectedMemory( rhs.protectedMemory )
- , samplerYcbcrConversion( rhs.samplerYcbcrConversion )
- , shaderDrawParameters( rhs.shaderDrawParameters )
- {}
-
PhysicalDeviceVulkan11Features & operator=( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceVulkan11Features ) - offsetof( PhysicalDeviceVulkan11Features, pNext ) );
VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault_ = {},
uint32_t maxPerSetDescriptors_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize_ = {} ) VULKAN_HPP_NOEXCEPT
- : deviceUUID{}
- , driverUUID{}
- , deviceLUID{}
+ : deviceUUID( deviceUUID_ )
+ , driverUUID( driverUUID_ )
+ , deviceLUID( deviceLUID_ )
, deviceNodeMask( deviceNodeMask_ )
, deviceLUIDValid( deviceLUIDValid_ )
, subgroupSize( subgroupSize_ )
, protectedNoFault( protectedNoFault_ )
, maxPerSetDescriptors( maxPerSetDescriptors_ )
, maxMemoryAllocationSize( maxMemoryAllocationSize_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( deviceUUID, deviceUUID_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( driverUUID, driverUUID_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_LUID_SIZE>::copy( deviceLUID, deviceLUID_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( PhysicalDeviceVulkan11Properties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , deviceUUID{}
- , driverUUID{}
- , deviceLUID{}
- , deviceNodeMask( rhs.deviceNodeMask )
- , deviceLUIDValid( rhs.deviceLUIDValid )
- , subgroupSize( rhs.subgroupSize )
- , subgroupSupportedStages( rhs.subgroupSupportedStages )
- , subgroupSupportedOperations( rhs.subgroupSupportedOperations )
- , subgroupQuadOperationsInAllStages( rhs.subgroupQuadOperationsInAllStages )
- , pointClippingBehavior( rhs.pointClippingBehavior )
- , maxMultiviewViewCount( rhs.maxMultiviewViewCount )
- , maxMultiviewInstanceIndex( rhs.maxMultiviewInstanceIndex )
- , protectedNoFault( rhs.protectedNoFault )
- , maxPerSetDescriptors( rhs.maxPerSetDescriptors )
- , maxMemoryAllocationSize( rhs.maxMemoryAllocationSize )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( deviceUUID, rhs.deviceUUID );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_UUID_SIZE>::copy( driverUUID, rhs.driverUUID );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint8_t,VK_LUID_SIZE>::copy( deviceLUID, rhs.deviceLUID );
- }
+ {}
PhysicalDeviceVulkan11Properties & operator=( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT
{
return *this;
}
- PhysicalDeviceVulkan11Properties & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setDeviceUUID( std::array<uint8_t,VK_UUID_SIZE> deviceUUID_ ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( deviceUUID, deviceUUID_.data(), VK_UUID_SIZE * sizeof( uint8_t ) );
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setDriverUUID( std::array<uint8_t,VK_UUID_SIZE> driverUUID_ ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( driverUUID, driverUUID_.data(), VK_UUID_SIZE * sizeof( uint8_t ) );
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setDeviceLUID( std::array<uint8_t,VK_LUID_SIZE> deviceLUID_ ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( deviceLUID, deviceLUID_.data(), VK_LUID_SIZE * sizeof( uint8_t ) );
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setDeviceNodeMask( uint32_t deviceNodeMask_ ) VULKAN_HPP_NOEXCEPT
- {
- deviceNodeMask = deviceNodeMask_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setDeviceLUIDValid( VULKAN_HPP_NAMESPACE::Bool32 deviceLUIDValid_ ) VULKAN_HPP_NOEXCEPT
- {
- deviceLUIDValid = deviceLUIDValid_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setSubgroupSize( uint32_t subgroupSize_ ) VULKAN_HPP_NOEXCEPT
- {
- subgroupSize = subgroupSize_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setSubgroupSupportedStages( VULKAN_HPP_NAMESPACE::ShaderStageFlags subgroupSupportedStages_ ) VULKAN_HPP_NOEXCEPT
- {
- subgroupSupportedStages = subgroupSupportedStages_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setSubgroupSupportedOperations( VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags subgroupSupportedOperations_ ) VULKAN_HPP_NOEXCEPT
- {
- subgroupSupportedOperations = subgroupSupportedOperations_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setSubgroupQuadOperationsInAllStages( VULKAN_HPP_NAMESPACE::Bool32 subgroupQuadOperationsInAllStages_ ) VULKAN_HPP_NOEXCEPT
- {
- subgroupQuadOperationsInAllStages = subgroupQuadOperationsInAllStages_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setPointClippingBehavior( VULKAN_HPP_NAMESPACE::PointClippingBehavior pointClippingBehavior_ ) VULKAN_HPP_NOEXCEPT
- {
- pointClippingBehavior = pointClippingBehavior_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setMaxMultiviewViewCount( uint32_t maxMultiviewViewCount_ ) VULKAN_HPP_NOEXCEPT
- {
- maxMultiviewViewCount = maxMultiviewViewCount_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setMaxMultiviewInstanceIndex( uint32_t maxMultiviewInstanceIndex_ ) VULKAN_HPP_NOEXCEPT
- {
- maxMultiviewInstanceIndex = maxMultiviewInstanceIndex_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setProtectedNoFault( VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault_ ) VULKAN_HPP_NOEXCEPT
- {
- protectedNoFault = protectedNoFault_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setMaxPerSetDescriptors( uint32_t maxPerSetDescriptors_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerSetDescriptors = maxPerSetDescriptors_;
- return *this;
- }
-
- PhysicalDeviceVulkan11Properties & setMaxMemoryAllocationSize( VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize_ ) VULKAN_HPP_NOEXCEPT
- {
- maxMemoryAllocationSize = maxMemoryAllocationSize_;
- return *this;
- }
-
operator VkPhysicalDeviceVulkan11Properties const&() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>( this );
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( 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 * sizeof( uint8_t ) ) == 0 )
+ && ( deviceUUID == rhs.deviceUUID )
+ && ( driverUUID == rhs.driverUUID )
+ && ( deviceLUID == rhs.deviceLUID )
&& ( deviceNodeMask == rhs.deviceNodeMask )
&& ( deviceLUIDValid == rhs.deviceLUIDValid )
&& ( subgroupSize == rhs.subgroupSize )
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan11Properties;
void* pNext = {};
- uint8_t deviceUUID[VK_UUID_SIZE] = {};
- uint8_t driverUUID[VK_UUID_SIZE] = {};
- uint8_t deviceLUID[VK_LUID_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> deviceUUID = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> driverUUID = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> deviceLUID = {};
uint32_t deviceNodeMask = {};
VULKAN_HPP_NAMESPACE::Bool32 deviceLUIDValid = {};
uint32_t subgroupSize = {};
, subgroupBroadcastDynamicId( subgroupBroadcastDynamicId_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( PhysicalDeviceVulkan12Features const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , samplerMirrorClampToEdge( rhs.samplerMirrorClampToEdge )
- , drawIndirectCount( rhs.drawIndirectCount )
- , storageBuffer8BitAccess( rhs.storageBuffer8BitAccess )
- , uniformAndStorageBuffer8BitAccess( rhs.uniformAndStorageBuffer8BitAccess )
- , storagePushConstant8( rhs.storagePushConstant8 )
- , shaderBufferInt64Atomics( rhs.shaderBufferInt64Atomics )
- , shaderSharedInt64Atomics( rhs.shaderSharedInt64Atomics )
- , shaderFloat16( rhs.shaderFloat16 )
- , shaderInt8( rhs.shaderInt8 )
- , descriptorIndexing( rhs.descriptorIndexing )
- , shaderInputAttachmentArrayDynamicIndexing( rhs.shaderInputAttachmentArrayDynamicIndexing )
- , shaderUniformTexelBufferArrayDynamicIndexing( rhs.shaderUniformTexelBufferArrayDynamicIndexing )
- , shaderStorageTexelBufferArrayDynamicIndexing( rhs.shaderStorageTexelBufferArrayDynamicIndexing )
- , shaderUniformBufferArrayNonUniformIndexing( rhs.shaderUniformBufferArrayNonUniformIndexing )
- , shaderSampledImageArrayNonUniformIndexing( rhs.shaderSampledImageArrayNonUniformIndexing )
- , shaderStorageBufferArrayNonUniformIndexing( rhs.shaderStorageBufferArrayNonUniformIndexing )
- , shaderStorageImageArrayNonUniformIndexing( rhs.shaderStorageImageArrayNonUniformIndexing )
- , shaderInputAttachmentArrayNonUniformIndexing( rhs.shaderInputAttachmentArrayNonUniformIndexing )
- , shaderUniformTexelBufferArrayNonUniformIndexing( rhs.shaderUniformTexelBufferArrayNonUniformIndexing )
- , shaderStorageTexelBufferArrayNonUniformIndexing( rhs.shaderStorageTexelBufferArrayNonUniformIndexing )
- , descriptorBindingUniformBufferUpdateAfterBind( rhs.descriptorBindingUniformBufferUpdateAfterBind )
- , descriptorBindingSampledImageUpdateAfterBind( rhs.descriptorBindingSampledImageUpdateAfterBind )
- , descriptorBindingStorageImageUpdateAfterBind( rhs.descriptorBindingStorageImageUpdateAfterBind )
- , descriptorBindingStorageBufferUpdateAfterBind( rhs.descriptorBindingStorageBufferUpdateAfterBind )
- , descriptorBindingUniformTexelBufferUpdateAfterBind( rhs.descriptorBindingUniformTexelBufferUpdateAfterBind )
- , descriptorBindingStorageTexelBufferUpdateAfterBind( rhs.descriptorBindingStorageTexelBufferUpdateAfterBind )
- , descriptorBindingUpdateUnusedWhilePending( rhs.descriptorBindingUpdateUnusedWhilePending )
- , descriptorBindingPartiallyBound( rhs.descriptorBindingPartiallyBound )
- , descriptorBindingVariableDescriptorCount( rhs.descriptorBindingVariableDescriptorCount )
- , runtimeDescriptorArray( rhs.runtimeDescriptorArray )
- , samplerFilterMinmax( rhs.samplerFilterMinmax )
- , scalarBlockLayout( rhs.scalarBlockLayout )
- , imagelessFramebuffer( rhs.imagelessFramebuffer )
- , uniformBufferStandardLayout( rhs.uniformBufferStandardLayout )
- , shaderSubgroupExtendedTypes( rhs.shaderSubgroupExtendedTypes )
- , separateDepthStencilLayouts( rhs.separateDepthStencilLayouts )
- , hostQueryReset( rhs.hostQueryReset )
- , timelineSemaphore( rhs.timelineSemaphore )
- , bufferDeviceAddress( rhs.bufferDeviceAddress )
- , bufferDeviceAddressCaptureReplay( rhs.bufferDeviceAddressCaptureReplay )
- , bufferDeviceAddressMultiDevice( rhs.bufferDeviceAddressMultiDevice )
- , vulkanMemoryModel( rhs.vulkanMemoryModel )
- , vulkanMemoryModelDeviceScope( rhs.vulkanMemoryModelDeviceScope )
- , vulkanMemoryModelAvailabilityVisibilityChains( rhs.vulkanMemoryModelAvailabilityVisibilityChains )
- , shaderOutputViewportIndex( rhs.shaderOutputViewportIndex )
- , shaderOutputLayer( rhs.shaderOutputLayer )
- , subgroupBroadcastDynamicId( rhs.subgroupBroadcastDynamicId )
- {}
-
PhysicalDeviceVulkan12Features & operator=( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceVulkan12Features ) - offsetof( PhysicalDeviceVulkan12Features, pNext ) );
uint64_t maxTimelineSemaphoreValueDifference_ = {},
VULKAN_HPP_NAMESPACE::SampleCountFlags framebufferIntegerColorSampleCounts_ = {} ) VULKAN_HPP_NOEXCEPT
: driverID( driverID_ )
- , driverName{}
- , driverInfo{}
+ , driverName( driverName_ )
+ , driverInfo( driverInfo_ )
, conformanceVersion( conformanceVersion_ )
, denormBehaviorIndependence( denormBehaviorIndependence_ )
, roundingModeIndependence( roundingModeIndependence_ )
, filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ )
, maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ )
, framebufferIntegerColorSampleCounts( framebufferIntegerColorSampleCounts_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_NAME_SIZE>::copy( driverName, driverName_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_INFO_SIZE>::copy( driverInfo, driverInfo_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( PhysicalDeviceVulkan12Properties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , driverID( rhs.driverID )
- , driverName{}
- , driverInfo{}
- , conformanceVersion( rhs.conformanceVersion )
- , denormBehaviorIndependence( rhs.denormBehaviorIndependence )
- , roundingModeIndependence( rhs.roundingModeIndependence )
- , shaderSignedZeroInfNanPreserveFloat16( rhs.shaderSignedZeroInfNanPreserveFloat16 )
- , shaderSignedZeroInfNanPreserveFloat32( rhs.shaderSignedZeroInfNanPreserveFloat32 )
- , shaderSignedZeroInfNanPreserveFloat64( rhs.shaderSignedZeroInfNanPreserveFloat64 )
- , shaderDenormPreserveFloat16( rhs.shaderDenormPreserveFloat16 )
- , shaderDenormPreserveFloat32( rhs.shaderDenormPreserveFloat32 )
- , shaderDenormPreserveFloat64( rhs.shaderDenormPreserveFloat64 )
- , shaderDenormFlushToZeroFloat16( rhs.shaderDenormFlushToZeroFloat16 )
- , shaderDenormFlushToZeroFloat32( rhs.shaderDenormFlushToZeroFloat32 )
- , shaderDenormFlushToZeroFloat64( rhs.shaderDenormFlushToZeroFloat64 )
- , shaderRoundingModeRTEFloat16( rhs.shaderRoundingModeRTEFloat16 )
- , shaderRoundingModeRTEFloat32( rhs.shaderRoundingModeRTEFloat32 )
- , shaderRoundingModeRTEFloat64( rhs.shaderRoundingModeRTEFloat64 )
- , shaderRoundingModeRTZFloat16( rhs.shaderRoundingModeRTZFloat16 )
- , shaderRoundingModeRTZFloat32( rhs.shaderRoundingModeRTZFloat32 )
- , shaderRoundingModeRTZFloat64( rhs.shaderRoundingModeRTZFloat64 )
- , maxUpdateAfterBindDescriptorsInAllPools( rhs.maxUpdateAfterBindDescriptorsInAllPools )
- , shaderUniformBufferArrayNonUniformIndexingNative( rhs.shaderUniformBufferArrayNonUniformIndexingNative )
- , shaderSampledImageArrayNonUniformIndexingNative( rhs.shaderSampledImageArrayNonUniformIndexingNative )
- , shaderStorageBufferArrayNonUniformIndexingNative( rhs.shaderStorageBufferArrayNonUniformIndexingNative )
- , shaderStorageImageArrayNonUniformIndexingNative( rhs.shaderStorageImageArrayNonUniformIndexingNative )
- , shaderInputAttachmentArrayNonUniformIndexingNative( rhs.shaderInputAttachmentArrayNonUniformIndexingNative )
- , robustBufferAccessUpdateAfterBind( rhs.robustBufferAccessUpdateAfterBind )
- , quadDivergentImplicitLod( rhs.quadDivergentImplicitLod )
- , maxPerStageDescriptorUpdateAfterBindSamplers( rhs.maxPerStageDescriptorUpdateAfterBindSamplers )
- , maxPerStageDescriptorUpdateAfterBindUniformBuffers( rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers )
- , maxPerStageDescriptorUpdateAfterBindStorageBuffers( rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers )
- , maxPerStageDescriptorUpdateAfterBindSampledImages( rhs.maxPerStageDescriptorUpdateAfterBindSampledImages )
- , maxPerStageDescriptorUpdateAfterBindStorageImages( rhs.maxPerStageDescriptorUpdateAfterBindStorageImages )
- , maxPerStageDescriptorUpdateAfterBindInputAttachments( rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments )
- , maxPerStageUpdateAfterBindResources( rhs.maxPerStageUpdateAfterBindResources )
- , maxDescriptorSetUpdateAfterBindSamplers( rhs.maxDescriptorSetUpdateAfterBindSamplers )
- , maxDescriptorSetUpdateAfterBindUniformBuffers( rhs.maxDescriptorSetUpdateAfterBindUniformBuffers )
- , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic( rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic )
- , maxDescriptorSetUpdateAfterBindStorageBuffers( rhs.maxDescriptorSetUpdateAfterBindStorageBuffers )
- , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic( rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic )
- , maxDescriptorSetUpdateAfterBindSampledImages( rhs.maxDescriptorSetUpdateAfterBindSampledImages )
- , maxDescriptorSetUpdateAfterBindStorageImages( rhs.maxDescriptorSetUpdateAfterBindStorageImages )
- , maxDescriptorSetUpdateAfterBindInputAttachments( rhs.maxDescriptorSetUpdateAfterBindInputAttachments )
- , supportedDepthResolveModes( rhs.supportedDepthResolveModes )
- , supportedStencilResolveModes( rhs.supportedStencilResolveModes )
- , independentResolveNone( rhs.independentResolveNone )
- , independentResolve( rhs.independentResolve )
- , filterMinmaxSingleComponentFormats( rhs.filterMinmaxSingleComponentFormats )
- , filterMinmaxImageComponentMapping( rhs.filterMinmaxImageComponentMapping )
- , maxTimelineSemaphoreValueDifference( rhs.maxTimelineSemaphoreValueDifference )
- , framebufferIntegerColorSampleCounts( rhs.framebufferIntegerColorSampleCounts )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_NAME_SIZE>::copy( driverName, rhs.driverName );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DRIVER_INFO_SIZE>::copy( driverInfo, rhs.driverInfo );
- }
+ {}
PhysicalDeviceVulkan12Properties & operator=( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT
{
return *this;
}
- PhysicalDeviceVulkan12Properties & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setDriverID( VULKAN_HPP_NAMESPACE::DriverId driverID_ ) VULKAN_HPP_NOEXCEPT
- {
- driverID = driverID_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setDriverName( std::array<char,VK_MAX_DRIVER_NAME_SIZE> driverName_ ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( driverName, driverName_.data(), VK_MAX_DRIVER_NAME_SIZE * sizeof( char ) );
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setDriverInfo( std::array<char,VK_MAX_DRIVER_INFO_SIZE> driverInfo_ ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( driverInfo, driverInfo_.data(), VK_MAX_DRIVER_INFO_SIZE * sizeof( char ) );
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setConformanceVersion( VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion_ ) VULKAN_HPP_NOEXCEPT
- {
- conformanceVersion = conformanceVersion_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setDenormBehaviorIndependence( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence denormBehaviorIndependence_ ) VULKAN_HPP_NOEXCEPT
- {
- denormBehaviorIndependence = denormBehaviorIndependence_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setRoundingModeIndependence( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence roundingModeIndependence_ ) VULKAN_HPP_NOEXCEPT
- {
- roundingModeIndependence = roundingModeIndependence_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderSignedZeroInfNanPreserveFloat16( VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat16_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderSignedZeroInfNanPreserveFloat16 = shaderSignedZeroInfNanPreserveFloat16_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderSignedZeroInfNanPreserveFloat32( VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat32_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderSignedZeroInfNanPreserveFloat32 = shaderSignedZeroInfNanPreserveFloat32_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderSignedZeroInfNanPreserveFloat64( VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat64_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderSignedZeroInfNanPreserveFloat64 = shaderSignedZeroInfNanPreserveFloat64_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderDenormPreserveFloat16( VULKAN_HPP_NAMESPACE::Bool32 shaderDenormPreserveFloat16_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderDenormPreserveFloat16 = shaderDenormPreserveFloat16_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderDenormPreserveFloat32( VULKAN_HPP_NAMESPACE::Bool32 shaderDenormPreserveFloat32_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderDenormPreserveFloat32 = shaderDenormPreserveFloat32_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderDenormPreserveFloat64( VULKAN_HPP_NAMESPACE::Bool32 shaderDenormPreserveFloat64_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderDenormPreserveFloat64 = shaderDenormPreserveFloat64_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderDenormFlushToZeroFloat16( VULKAN_HPP_NAMESPACE::Bool32 shaderDenormFlushToZeroFloat16_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderDenormFlushToZeroFloat16 = shaderDenormFlushToZeroFloat16_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderDenormFlushToZeroFloat32( VULKAN_HPP_NAMESPACE::Bool32 shaderDenormFlushToZeroFloat32_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderDenormFlushToZeroFloat32 = shaderDenormFlushToZeroFloat32_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderDenormFlushToZeroFloat64( VULKAN_HPP_NAMESPACE::Bool32 shaderDenormFlushToZeroFloat64_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderDenormFlushToZeroFloat64 = shaderDenormFlushToZeroFloat64_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderRoundingModeRTEFloat16( VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTEFloat16_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderRoundingModeRTEFloat16 = shaderRoundingModeRTEFloat16_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderRoundingModeRTEFloat32( VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTEFloat32_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderRoundingModeRTEFloat32 = shaderRoundingModeRTEFloat32_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderRoundingModeRTEFloat64( VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTEFloat64_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderRoundingModeRTEFloat64 = shaderRoundingModeRTEFloat64_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderRoundingModeRTZFloat16( VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat16_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderRoundingModeRTZFloat16 = shaderRoundingModeRTZFloat16_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderRoundingModeRTZFloat32( VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat32_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderRoundingModeRTZFloat32 = shaderRoundingModeRTZFloat32_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderRoundingModeRTZFloat64( VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat64_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderRoundingModeRTZFloat64 = shaderRoundingModeRTZFloat64_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxUpdateAfterBindDescriptorsInAllPools( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ ) VULKAN_HPP_NOEXCEPT
- {
- maxUpdateAfterBindDescriptorsInAllPools = maxUpdateAfterBindDescriptorsInAllPools_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderUniformBufferArrayNonUniformIndexingNative( VULKAN_HPP_NAMESPACE::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderUniformBufferArrayNonUniformIndexingNative = shaderUniformBufferArrayNonUniformIndexingNative_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderSampledImageArrayNonUniformIndexingNative( VULKAN_HPP_NAMESPACE::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderSampledImageArrayNonUniformIndexingNative = shaderSampledImageArrayNonUniformIndexingNative_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderStorageBufferArrayNonUniformIndexingNative( VULKAN_HPP_NAMESPACE::Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderStorageBufferArrayNonUniformIndexingNative = shaderStorageBufferArrayNonUniformIndexingNative_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderStorageImageArrayNonUniformIndexingNative( VULKAN_HPP_NAMESPACE::Bool32 shaderStorageImageArrayNonUniformIndexingNative_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderStorageImageArrayNonUniformIndexingNative = shaderStorageImageArrayNonUniformIndexingNative_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setShaderInputAttachmentArrayNonUniformIndexingNative( VULKAN_HPP_NAMESPACE::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ ) VULKAN_HPP_NOEXCEPT
- {
- shaderInputAttachmentArrayNonUniformIndexingNative = shaderInputAttachmentArrayNonUniformIndexingNative_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setRobustBufferAccessUpdateAfterBind( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccessUpdateAfterBind_ ) VULKAN_HPP_NOEXCEPT
- {
- robustBufferAccessUpdateAfterBind = robustBufferAccessUpdateAfterBind_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setQuadDivergentImplicitLod( VULKAN_HPP_NAMESPACE::Bool32 quadDivergentImplicitLod_ ) VULKAN_HPP_NOEXCEPT
- {
- quadDivergentImplicitLod = quadDivergentImplicitLod_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageDescriptorUpdateAfterBindSamplers( uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageDescriptorUpdateAfterBindSamplers = maxPerStageDescriptorUpdateAfterBindSamplers_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageDescriptorUpdateAfterBindUniformBuffers( uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageDescriptorUpdateAfterBindUniformBuffers = maxPerStageDescriptorUpdateAfterBindUniformBuffers_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageDescriptorUpdateAfterBindStorageBuffers( uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageDescriptorUpdateAfterBindStorageBuffers = maxPerStageDescriptorUpdateAfterBindStorageBuffers_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageDescriptorUpdateAfterBindSampledImages( uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageDescriptorUpdateAfterBindSampledImages = maxPerStageDescriptorUpdateAfterBindSampledImages_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageDescriptorUpdateAfterBindStorageImages( uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageDescriptorUpdateAfterBindStorageImages = maxPerStageDescriptorUpdateAfterBindStorageImages_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageDescriptorUpdateAfterBindInputAttachments( uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageDescriptorUpdateAfterBindInputAttachments = maxPerStageDescriptorUpdateAfterBindInputAttachments_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxPerStageUpdateAfterBindResources( uint32_t maxPerStageUpdateAfterBindResources_ ) VULKAN_HPP_NOEXCEPT
- {
- maxPerStageUpdateAfterBindResources = maxPerStageUpdateAfterBindResources_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindSamplers( uint32_t maxDescriptorSetUpdateAfterBindSamplers_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindSamplers = maxDescriptorSetUpdateAfterBindSamplers_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindUniformBuffers( uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindUniformBuffers = maxDescriptorSetUpdateAfterBindUniformBuffers_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindUniformBuffersDynamic( uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindStorageBuffers( uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindStorageBuffers = maxDescriptorSetUpdateAfterBindStorageBuffers_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindStorageBuffersDynamic( uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindSampledImages( uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindSampledImages = maxDescriptorSetUpdateAfterBindSampledImages_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindStorageImages( uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindStorageImages = maxDescriptorSetUpdateAfterBindStorageImages_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxDescriptorSetUpdateAfterBindInputAttachments( uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ ) VULKAN_HPP_NOEXCEPT
- {
- maxDescriptorSetUpdateAfterBindInputAttachments = maxDescriptorSetUpdateAfterBindInputAttachments_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setSupportedDepthResolveModes( VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedDepthResolveModes_ ) VULKAN_HPP_NOEXCEPT
- {
- supportedDepthResolveModes = supportedDepthResolveModes_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setSupportedStencilResolveModes( VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes_ ) VULKAN_HPP_NOEXCEPT
- {
- supportedStencilResolveModes = supportedStencilResolveModes_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setIndependentResolveNone( VULKAN_HPP_NAMESPACE::Bool32 independentResolveNone_ ) VULKAN_HPP_NOEXCEPT
- {
- independentResolveNone = independentResolveNone_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setIndependentResolve( VULKAN_HPP_NAMESPACE::Bool32 independentResolve_ ) VULKAN_HPP_NOEXCEPT
- {
- independentResolve = independentResolve_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setFilterMinmaxSingleComponentFormats( VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats_ ) VULKAN_HPP_NOEXCEPT
- {
- filterMinmaxSingleComponentFormats = filterMinmaxSingleComponentFormats_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setFilterMinmaxImageComponentMapping( VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping_ ) VULKAN_HPP_NOEXCEPT
- {
- filterMinmaxImageComponentMapping = filterMinmaxImageComponentMapping_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setMaxTimelineSemaphoreValueDifference( uint64_t maxTimelineSemaphoreValueDifference_ ) VULKAN_HPP_NOEXCEPT
- {
- maxTimelineSemaphoreValueDifference = maxTimelineSemaphoreValueDifference_;
- return *this;
- }
-
- PhysicalDeviceVulkan12Properties & setFramebufferIntegerColorSampleCounts( VULKAN_HPP_NAMESPACE::SampleCountFlags framebufferIntegerColorSampleCounts_ ) VULKAN_HPP_NOEXCEPT
- {
- framebufferIntegerColorSampleCounts = framebufferIntegerColorSampleCounts_;
- return *this;
- }
-
operator VkPhysicalDeviceVulkan12Properties const&() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>( this );
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( driverID == rhs.driverID )
- && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof( char ) ) == 0 )
+ && ( driverName == rhs.driverName )
+ && ( driverInfo == rhs.driverInfo )
&& ( conformanceVersion == rhs.conformanceVersion )
&& ( denormBehaviorIndependence == rhs.denormBehaviorIndependence )
&& ( roundingModeIndependence == rhs.roundingModeIndependence )
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan12Properties;
void* pNext = {};
VULKAN_HPP_NAMESPACE::DriverId driverID = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary;
- char driverName[VK_MAX_DRIVER_NAME_SIZE] = {};
- char driverInfo[VK_MAX_DRIVER_INFO_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> driverName = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> driverInfo = {};
VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion = {};
VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence denormBehaviorIndependence = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly;
VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence roundingModeIndependence = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly;
, vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( PhysicalDeviceVulkanMemoryModelFeatures const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , vulkanMemoryModel( rhs.vulkanMemoryModel )
- , vulkanMemoryModelDeviceScope( rhs.vulkanMemoryModelDeviceScope )
- , vulkanMemoryModelAvailabilityVisibilityChains( rhs.vulkanMemoryModelAvailabilityVisibilityChains )
- {}
-
PhysicalDeviceVulkanMemoryModelFeatures & operator=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceVulkanMemoryModelFeatures ) - offsetof( PhysicalDeviceVulkanMemoryModelFeatures, pNext ) );
: ycbcrImageArrays( ycbcrImageArrays_ )
{}
- VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( PhysicalDeviceYcbcrImageArraysFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , ycbcrImageArrays( rhs.ycbcrImageArrays )
- {}
-
PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) - offsetof( PhysicalDeviceYcbcrImageArraysFeaturesEXT, pNext ) );
, pInitialData( pInitialData_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( PipelineCacheCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , initialDataSize( rhs.initialDataSize )
- , pInitialData( rhs.pInitialData )
- {}
-
PipelineCacheCreateInfo & operator=( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineCacheCreateInfo ) - offsetof( PipelineCacheCreateInfo, pNext ) );
, blendOverlap( blendOverlap_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , srcPremultiplied( rhs.srcPremultiplied )
- , dstPremultiplied( rhs.dstPremultiplied )
- , blendOverlap( rhs.blendOverlap )
- {}
-
PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) - offsetof( PipelineColorBlendAdvancedStateCreateInfoEXT, pNext ) );
: compilerControlFlags( compilerControlFlags_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( PipelineCompilerControlCreateInfoAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , compilerControlFlags( rhs.compilerControlFlags )
- {}
-
PipelineCompilerControlCreateInfoAMD & operator=( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineCompilerControlCreateInfoAMD ) - offsetof( PipelineCompilerControlCreateInfoAMD, pNext ) );
, pCoverageModulationTable( pCoverageModulationTable_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , coverageModulationMode( rhs.coverageModulationMode )
- , coverageModulationTableEnable( rhs.coverageModulationTableEnable )
- , coverageModulationTableCount( rhs.coverageModulationTableCount )
- , pCoverageModulationTable( rhs.pCoverageModulationTable )
- {}
-
PipelineCoverageModulationStateCreateInfoNV & operator=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineCoverageModulationStateCreateInfoNV ) - offsetof( PipelineCoverageModulationStateCreateInfoNV, pNext ) );
, coverageReductionMode( coverageReductionMode_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , coverageReductionMode( rhs.coverageReductionMode )
- {}
-
PipelineCoverageReductionStateCreateInfoNV & operator=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineCoverageReductionStateCreateInfoNV ) - offsetof( PipelineCoverageReductionStateCreateInfoNV, pNext ) );
, coverageToColorLocation( coverageToColorLocation_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , coverageToColorEnable( rhs.coverageToColorEnable )
- , coverageToColorLocation( rhs.coverageToColorLocation )
- {}
-
PipelineCoverageToColorStateCreateInfoNV & operator=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineCoverageToColorStateCreateInfoNV ) - offsetof( PipelineCoverageToColorStateCreateInfoNV, pNext ) );
, duration( duration_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackEXT( PipelineCreationFeedbackEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : flags( rhs.flags )
- , duration( rhs.duration )
- {}
-
- PipelineCreationFeedbackEXT & operator=( PipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PipelineCreationFeedbackEXT ) );
- return *this;
- }
-
PipelineCreationFeedbackEXT( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( PipelineCreationFeedbackCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pPipelineCreationFeedback( rhs.pPipelineCreationFeedback )
- , pipelineStageCreationFeedbackCount( rhs.pipelineStageCreationFeedbackCount )
- , pPipelineStageCreationFeedbacks( rhs.pPipelineStageCreationFeedbacks )
- {}
-
PipelineCreationFeedbackCreateInfoEXT & operator=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineCreationFeedbackCreateInfoEXT ) - offsetof( PipelineCreationFeedbackCreateInfoEXT, pNext ) );
, pDiscardRectangles( pDiscardRectangles_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , discardRectangleMode( rhs.discardRectangleMode )
- , discardRectangleCount( rhs.discardRectangleCount )
- , pDiscardRectangles( rhs.pDiscardRectangles )
- {}
-
PipelineDiscardRectangleStateCreateInfoEXT & operator=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) - offsetof( PipelineDiscardRectangleStateCreateInfoEXT, pNext ) );
, executableIndex( executableIndex_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( PipelineExecutableInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pipeline( rhs.pipeline )
- , executableIndex( rhs.executableIndex )
- {}
-
PipelineExecutableInfoKHR & operator=( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineExecutableInfoKHR ) - offsetof( PipelineExecutableInfoKHR, pNext ) );
VULKAN_HPP_NAMESPACE::Bool32 isText_ = {},
size_t dataSize_ = {},
void* pData_ = {} ) VULKAN_HPP_NOEXCEPT
- : name{}
- , description{}
+ : name( name_ )
+ , description( description_ )
, isText( isText_ )
, dataSize( dataSize_ )
, pData( pData_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( PipelineExecutableInternalRepresentationKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , name{}
- , description{}
- , isText( rhs.isText )
- , dataSize( rhs.dataSize )
- , pData( rhs.pData )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, rhs.name );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, rhs.description );
- }
+ {}
PipelineExecutableInternalRepresentationKHR & operator=( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+ && ( name == rhs.name )
+ && ( description == rhs.description )
&& ( isText == rhs.isText )
&& ( dataSize == rhs.dataSize )
&& ( pData == rhs.pData );
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR;
void* pNext = {};
- char name[VK_MAX_DESCRIPTION_SIZE] = {};
- char description[VK_MAX_DESCRIPTION_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
VULKAN_HPP_NAMESPACE::Bool32 isText = {};
size_t dataSize = {};
void* pData = {};
std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {},
uint32_t subgroupSize_ = {} ) VULKAN_HPP_NOEXCEPT
: stages( stages_ )
- , name{}
- , description{}
+ , name( name_ )
+ , description( description_ )
, subgroupSize( subgroupSize_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( PipelineExecutablePropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , stages( rhs.stages )
- , name{}
- , description{}
- , subgroupSize( rhs.subgroupSize )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, rhs.name );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, rhs.description );
- }
+ {}
PipelineExecutablePropertiesKHR & operator=( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( stages == rhs.stages )
- && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+ && ( name == rhs.name )
+ && ( description == rhs.description )
&& ( subgroupSize == rhs.subgroupSize );
}
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR;
void* pNext = {};
VULKAN_HPP_NAMESPACE::ShaderStageFlags stages = {};
- char name[VK_MAX_DESCRIPTION_SIZE] = {};
- char description[VK_MAX_DESCRIPTION_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
uint32_t subgroupSize = {};
};
static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" );
std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {},
VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format_ = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32,
VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR value_ = {} ) VULKAN_HPP_NOEXCEPT
- : name{}
- , description{}
+ : name( name_ )
+ , description( description_ )
, format( format_ )
, value( value_ )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- }
-
- PipelineExecutableStatisticKHR( PipelineExecutableStatisticKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , name{}
- , description{}
- , format( rhs.format )
- , value( rhs.value )
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( name, rhs.name );
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<char,VK_MAX_DESCRIPTION_SIZE>::copy( description, rhs.description );
- }
+ {}
PipelineExecutableStatisticKHR & operator=( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
public:
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
void* pNext = {};
- char name[VK_MAX_DESCRIPTION_SIZE] = {};
- char description[VK_MAX_DESCRIPTION_SIZE] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {};
VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32;
VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR value = {};
};
: pipeline( pipeline_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineInfoKHR( PipelineInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , pipeline( rhs.pipeline )
- {}
-
PipelineInfoKHR & operator=( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineInfoKHR ) - offsetof( PipelineInfoKHR, pNext ) );
, size( size_ )
{}
- VULKAN_HPP_CONSTEXPR PushConstantRange( PushConstantRange const& rhs ) VULKAN_HPP_NOEXCEPT
- : stageFlags( rhs.stageFlags )
- , offset( rhs.offset )
- , size( rhs.size )
- {}
-
- PushConstantRange & operator=( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PushConstantRange ) );
- return *this;
- }
-
PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pPushConstantRanges( pPushConstantRanges_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( PipelineLayoutCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , setLayoutCount( rhs.setLayoutCount )
- , pSetLayouts( rhs.pSetLayouts )
- , pushConstantRangeCount( rhs.pushConstantRangeCount )
- , pPushConstantRanges( rhs.pPushConstantRanges )
- {}
-
PipelineLayoutCreateInfo & operator=( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineLayoutCreateInfo ) - offsetof( PipelineLayoutCreateInfo, pNext ) );
, pLibraries( pLibraries_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( PipelineLibraryCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , libraryCount( rhs.libraryCount )
- , pLibraries( rhs.pLibraries )
- {}
-
PipelineLibraryCreateInfoKHR & operator=( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineLibraryCreateInfoKHR ) - offsetof( PipelineLibraryCreateInfoKHR, pNext ) );
, extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , conservativeRasterizationMode( rhs.conservativeRasterizationMode )
- , extraPrimitiveOverestimationSize( rhs.extraPrimitiveOverestimationSize )
- {}
-
PipelineRasterizationConservativeStateCreateInfoEXT & operator=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) - offsetof( PipelineRasterizationConservativeStateCreateInfoEXT, pNext ) );
, depthClipEnable( depthClipEnable_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , depthClipEnable( rhs.depthClipEnable )
- {}
-
PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) - offsetof( PipelineRasterizationDepthClipStateCreateInfoEXT, pNext ) );
, lineStipplePattern( lineStipplePattern_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , lineRasterizationMode( rhs.lineRasterizationMode )
- , stippledLineEnable( rhs.stippledLineEnable )
- , lineStippleFactor( rhs.lineStippleFactor )
- , lineStipplePattern( rhs.lineStipplePattern )
- {}
-
PipelineRasterizationLineStateCreateInfoEXT & operator=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationLineStateCreateInfoEXT ) - offsetof( PipelineRasterizationLineStateCreateInfoEXT, pNext ) );
: rasterizationOrder( rasterizationOrder_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , rasterizationOrder( rhs.rasterizationOrder )
- {}
-
PipelineRasterizationStateRasterizationOrderAMD & operator=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) - offsetof( PipelineRasterizationStateRasterizationOrderAMD, pNext ) );
, rasterizationStream( rasterizationStream_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , rasterizationStream( rhs.rasterizationStream )
- {}
-
PipelineRasterizationStateStreamCreateInfoEXT & operator=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) - offsetof( PipelineRasterizationStateStreamCreateInfoEXT, pNext ) );
: representativeFragmentTestEnable( representativeFragmentTestEnable_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , representativeFragmentTestEnable( rhs.representativeFragmentTestEnable )
- {}
-
PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) - offsetof( PipelineRepresentativeFragmentTestStateCreateInfoNV, pNext ) );
, sampleLocationsInfo( sampleLocationsInfo_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , sampleLocationsEnable( rhs.sampleLocationsEnable )
- , sampleLocationsInfo( rhs.sampleLocationsInfo )
- {}
-
PipelineSampleLocationsStateCreateInfoEXT & operator=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) - offsetof( PipelineSampleLocationsStateCreateInfoEXT, pNext ) );
: requiredSubgroupSize( requiredSubgroupSize_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , requiredSubgroupSize( rhs.requiredSubgroupSize )
- {}
-
PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT & operator=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) - offsetof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT, pNext ) );
: domainOrigin( domainOrigin_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , domainOrigin( rhs.domainOrigin )
- {}
-
PipelineTessellationDomainOriginStateCreateInfo & operator=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) - offsetof( PipelineTessellationDomainOriginStateCreateInfo, pNext ) );
, divisor( divisor_ )
{}
- VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescriptionEXT( VertexInputBindingDivisorDescriptionEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : binding( rhs.binding )
- , divisor( rhs.divisor )
- {}
-
- VertexInputBindingDivisorDescriptionEXT & operator=( VertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
- return *this;
- }
-
VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pVertexBindingDivisors( pVertexBindingDivisors_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , vertexBindingDivisorCount( rhs.vertexBindingDivisorCount )
- , pVertexBindingDivisors( rhs.pVertexBindingDivisors )
- {}
-
PipelineVertexInputDivisorStateCreateInfoEXT & operator=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) - offsetof( PipelineVertexInputDivisorStateCreateInfoEXT, pNext ) );
, pCustomSampleOrders( pCustomSampleOrders_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , sampleOrderType( rhs.sampleOrderType )
- , customSampleOrderCount( rhs.customSampleOrderCount )
- , pCustomSampleOrders( rhs.pCustomSampleOrders )
- {}
-
PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) - offsetof( PipelineViewportCoarseSampleOrderStateCreateInfoNV, pNext ) );
, pExclusiveScissors( pExclusiveScissors_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , exclusiveScissorCount( rhs.exclusiveScissorCount )
- , pExclusiveScissors( rhs.pExclusiveScissors )
- {}
-
PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) - offsetof( PipelineViewportExclusiveScissorStateCreateInfoNV, pNext ) );
, pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
{}
- VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( ShadingRatePaletteNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : shadingRatePaletteEntryCount( rhs.shadingRatePaletteEntryCount )
- , pShadingRatePaletteEntries( rhs.pShadingRatePaletteEntries )
- {}
-
- ShadingRatePaletteNV & operator=( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ShadingRatePaletteNV ) );
- return *this;
- }
-
ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pShadingRatePalettes( pShadingRatePalettes_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , shadingRateImageEnable( rhs.shadingRateImageEnable )
- , viewportCount( rhs.viewportCount )
- , pShadingRatePalettes( rhs.pShadingRatePalettes )
- {}
-
PipelineViewportShadingRateImageStateCreateInfoNV & operator=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) - offsetof( PipelineViewportShadingRateImageStateCreateInfoNV, pNext ) );
, w( w_ )
{}
- VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( ViewportSwizzleNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : x( rhs.x )
- , y( rhs.y )
- , z( rhs.z )
- , w( rhs.w )
- {}
-
- ViewportSwizzleNV & operator=( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ViewportSwizzleNV ) );
- return *this;
- }
-
ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pViewportSwizzles( pViewportSwizzles_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , viewportCount( rhs.viewportCount )
- , pViewportSwizzles( rhs.pViewportSwizzles )
- {}
-
PipelineViewportSwizzleStateCreateInfoNV & operator=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) - offsetof( PipelineViewportSwizzleStateCreateInfoNV, pNext ) );
, ycoeff( ycoeff_ )
{}
- VULKAN_HPP_CONSTEXPR ViewportWScalingNV( ViewportWScalingNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : xcoeff( rhs.xcoeff )
- , ycoeff( rhs.ycoeff )
- {}
-
- ViewportWScalingNV & operator=( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ViewportWScalingNV ) );
- return *this;
- }
-
ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pViewportWScalings( pViewportWScalings_ )
{}
- VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( PipelineViewportWScalingStateCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , viewportWScalingEnable( rhs.viewportWScalingEnable )
- , viewportCount( rhs.viewportCount )
- , pViewportWScalings( rhs.pViewportWScalings )
- {}
-
PipelineViewportWScalingStateCreateInfoNV & operator=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportWScalingStateCreateInfoNV ) - offsetof( PipelineViewportWScalingStateCreateInfoNV, pNext ) );
: frameToken( frameToken_ )
{}
- VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( PresentFrameTokenGGP const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , frameToken( rhs.frameToken )
- {}
-
PresentFrameTokenGGP & operator=( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PresentFrameTokenGGP ) - offsetof( PresentFrameTokenGGP, pNext ) );
, pResults( pResults_ )
{}
- VULKAN_HPP_CONSTEXPR PresentInfoKHR( PresentInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , waitSemaphoreCount( rhs.waitSemaphoreCount )
- , pWaitSemaphores( rhs.pWaitSemaphores )
- , swapchainCount( rhs.swapchainCount )
- , pSwapchains( rhs.pSwapchains )
- , pImageIndices( rhs.pImageIndices )
- , pResults( rhs.pResults )
- {}
-
PresentInfoKHR & operator=( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PresentInfoKHR ) - offsetof( PresentInfoKHR, pNext ) );
, layer( layer_ )
{}
- VULKAN_HPP_CONSTEXPR RectLayerKHR( RectLayerKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : offset( rhs.offset )
- , extent( rhs.extent )
- , layer( rhs.layer )
- {}
-
explicit RectLayerKHR( Rect2D const& rect2D,
uint32_t layer_ = {} )
: offset( rect2D.offset )
, layer( layer_ )
{}
- RectLayerKHR & operator=( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( RectLayerKHR ) );
- return *this;
- }
-
RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pRectangles( pRectangles_ )
{}
- VULKAN_HPP_CONSTEXPR PresentRegionKHR( PresentRegionKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : rectangleCount( rhs.rectangleCount )
- , pRectangles( rhs.pRectangles )
- {}
-
- PresentRegionKHR & operator=( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PresentRegionKHR ) );
- return *this;
- }
-
PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pRegions( pRegions_ )
{}
- VULKAN_HPP_CONSTEXPR PresentRegionsKHR( PresentRegionsKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , swapchainCount( rhs.swapchainCount )
- , pRegions( rhs.pRegions )
- {}
-
PresentRegionsKHR & operator=( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PresentRegionsKHR ) - offsetof( PresentRegionsKHR, pNext ) );
, desiredPresentTime( desiredPresentTime_ )
{}
- VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( PresentTimeGOOGLE const& rhs ) VULKAN_HPP_NOEXCEPT
- : presentID( rhs.presentID )
- , desiredPresentTime( rhs.desiredPresentTime )
- {}
-
- PresentTimeGOOGLE & operator=( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( PresentTimeGOOGLE ) );
- return *this;
- }
-
PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pTimes( pTimes_ )
{}
- VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( PresentTimesInfoGOOGLE const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , swapchainCount( rhs.swapchainCount )
- , pTimes( rhs.pTimes )
- {}
-
PresentTimesInfoGOOGLE & operator=( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( PresentTimesInfoGOOGLE ) - offsetof( PresentTimesInfoGOOGLE, pNext ) );
: protectedSubmit( protectedSubmit_ )
{}
- VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( ProtectedSubmitInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , protectedSubmit( rhs.protectedSubmit )
- {}
-
ProtectedSubmitInfo & operator=( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ProtectedSubmitInfo ) - offsetof( ProtectedSubmitInfo, pNext ) );
, pipelineStatistics( pipelineStatistics_ )
{}
- VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( QueryPoolCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , queryType( rhs.queryType )
- , queryCount( rhs.queryCount )
- , pipelineStatistics( rhs.pipelineStatistics )
- {}
-
QueryPoolCreateInfo & operator=( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( QueryPoolCreateInfo ) - offsetof( QueryPoolCreateInfo, pNext ) );
, pCounterIndices( pCounterIndices_ )
{}
- VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( QueryPoolPerformanceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , queueFamilyIndex( rhs.queueFamilyIndex )
- , counterIndexCount( rhs.counterIndexCount )
- , pCounterIndices( rhs.pCounterIndices )
- {}
-
QueryPoolPerformanceCreateInfoKHR & operator=( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( QueryPoolPerformanceCreateInfoKHR ) - offsetof( QueryPoolPerformanceCreateInfoKHR, pNext ) );
: performanceCountersSampling( performanceCountersSampling_ )
{}
- VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( QueryPoolPerformanceQueryCreateInfoINTEL const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , performanceCountersSampling( rhs.performanceCountersSampling )
- {}
-
QueryPoolPerformanceQueryCreateInfoINTEL & operator=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( QueryPoolPerformanceQueryCreateInfoINTEL ) - offsetof( QueryPoolPerformanceQueryCreateInfoINTEL, pNext ) );
: checkpointExecutionStageMask( checkpointExecutionStageMask_ )
{}
- VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( QueueFamilyCheckpointPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , checkpointExecutionStageMask( rhs.checkpointExecutionStageMask )
- {}
-
QueueFamilyCheckpointPropertiesNV & operator=( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( QueueFamilyCheckpointPropertiesNV ) - offsetof( QueueFamilyCheckpointPropertiesNV, pNext ) );
, minImageTransferGranularity( minImageTransferGranularity_ )
{}
- VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFamilyProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : queueFlags( rhs.queueFlags )
- , queueCount( rhs.queueCount )
- , timestampValidBits( rhs.timestampValidBits )
- , minImageTransferGranularity( rhs.minImageTransferGranularity )
- {}
-
- QueueFamilyProperties & operator=( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( QueueFamilyProperties ) );
- return *this;
- }
-
QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: queueFamilyProperties( queueFamilyProperties_ )
{}
- VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , queueFamilyProperties( rhs.queueFamilyProperties )
- {}
-
QueueFamilyProperties2 & operator=( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( QueueFamilyProperties2 ) - offsetof( QueueFamilyProperties2, pNext ) );
, pShaderGroupCaptureReplayHandle( pShaderGroupCaptureReplayHandle_ )
{}
- VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( RayTracingShaderGroupCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , generalShader( rhs.generalShader )
- , closestHitShader( rhs.closestHitShader )
- , anyHitShader( rhs.anyHitShader )
- , intersectionShader( rhs.intersectionShader )
- , pShaderGroupCaptureReplayHandle( rhs.pShaderGroupCaptureReplayHandle )
- {}
-
RayTracingShaderGroupCreateInfoKHR & operator=( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RayTracingShaderGroupCreateInfoKHR ) - offsetof( RayTracingShaderGroupCreateInfoKHR, pNext ) );
, maxCallableSize( maxCallableSize_ )
{}
- VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( RayTracingPipelineInterfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , maxPayloadSize( rhs.maxPayloadSize )
- , maxAttributeSize( rhs.maxAttributeSize )
- , maxCallableSize( rhs.maxCallableSize )
- {}
-
RayTracingPipelineInterfaceCreateInfoKHR & operator=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RayTracingPipelineInterfaceCreateInfoKHR ) - offsetof( RayTracingPipelineInterfaceCreateInfoKHR, pNext ) );
, basePipelineIndex( basePipelineIndex_ )
{}
- VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( RayTracingPipelineCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , stageCount( rhs.stageCount )
- , pStages( rhs.pStages )
- , groupCount( rhs.groupCount )
- , pGroups( rhs.pGroups )
- , maxRecursionDepth( rhs.maxRecursionDepth )
- , libraries( rhs.libraries )
- , pLibraryInterface( rhs.pLibraryInterface )
- , layout( rhs.layout )
- , basePipelineHandle( rhs.basePipelineHandle )
- , basePipelineIndex( rhs.basePipelineIndex )
- {}
-
RayTracingPipelineCreateInfoKHR & operator=( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RayTracingPipelineCreateInfoKHR ) - offsetof( RayTracingPipelineCreateInfoKHR, pNext ) );
, intersectionShader( intersectionShader_ )
{}
- VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , type( rhs.type )
- , generalShader( rhs.generalShader )
- , closestHitShader( rhs.closestHitShader )
- , anyHitShader( rhs.anyHitShader )
- , intersectionShader( rhs.intersectionShader )
- {}
-
RayTracingShaderGroupCreateInfoNV & operator=( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RayTracingShaderGroupCreateInfoNV ) - offsetof( RayTracingShaderGroupCreateInfoNV, pNext ) );
, basePipelineIndex( basePipelineIndex_ )
{}
- VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( RayTracingPipelineCreateInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , stageCount( rhs.stageCount )
- , pStages( rhs.pStages )
- , groupCount( rhs.groupCount )
- , pGroups( rhs.pGroups )
- , maxRecursionDepth( rhs.maxRecursionDepth )
- , layout( rhs.layout )
- , basePipelineHandle( rhs.basePipelineHandle )
- , basePipelineIndex( rhs.basePipelineIndex )
- {}
-
RayTracingPipelineCreateInfoNV & operator=( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RayTracingPipelineCreateInfoNV ) - offsetof( RayTracingPipelineCreateInfoNV, pNext ) );
: refreshDuration( refreshDuration_ )
{}
- VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( RefreshCycleDurationGOOGLE const& rhs ) VULKAN_HPP_NOEXCEPT
- : refreshDuration( rhs.refreshDuration )
- {}
-
- RefreshCycleDurationGOOGLE & operator=( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( RefreshCycleDurationGOOGLE ) );
- return *this;
- }
-
RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pAttachments( pAttachments_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( RenderPassAttachmentBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , attachmentCount( rhs.attachmentCount )
- , pAttachments( rhs.pAttachments )
- {}
-
RenderPassAttachmentBeginInfo & operator=( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassAttachmentBeginInfo ) - offsetof( RenderPassAttachmentBeginInfo, pNext ) );
, pClearValues( pClearValues_ )
{}
- VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPassBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , renderPass( rhs.renderPass )
- , framebuffer( rhs.framebuffer )
- , renderArea( rhs.renderArea )
- , clearValueCount( rhs.clearValueCount )
- , pClearValues( rhs.pClearValues )
- {}
-
RenderPassBeginInfo & operator=( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassBeginInfo ) - offsetof( RenderPassBeginInfo, pNext ) );
, pPreserveAttachments( pPreserveAttachments_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescription const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
- SubpassDescription & operator=( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SubpassDescription ) );
- return *this;
- }
-
SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, dependencyFlags( dependencyFlags_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassDependency( SubpassDependency const& rhs ) VULKAN_HPP_NOEXCEPT
- : srcSubpass( rhs.srcSubpass )
- , dstSubpass( rhs.dstSubpass )
- , srcStageMask( rhs.srcStageMask )
- , dstStageMask( rhs.dstStageMask )
- , srcAccessMask( rhs.srcAccessMask )
- , dstAccessMask( rhs.dstAccessMask )
- , dependencyFlags( rhs.dependencyFlags )
- {}
-
- SubpassDependency & operator=( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SubpassDependency ) );
- return *this;
- }
-
SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pDependencies( pDependencies_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , attachmentCount( rhs.attachmentCount )
- , pAttachments( rhs.pAttachments )
- , subpassCount( rhs.subpassCount )
- , pSubpasses( rhs.pSubpasses )
- , dependencyCount( rhs.dependencyCount )
- , pDependencies( rhs.pDependencies )
- {}
-
RenderPassCreateInfo & operator=( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassCreateInfo ) - offsetof( RenderPassCreateInfo, pNext ) );
, pPreserveAttachments( pPreserveAttachments_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassDescription2( SubpassDescription2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , pipelineBindPoint( rhs.pipelineBindPoint )
- , viewMask( rhs.viewMask )
- , inputAttachmentCount( rhs.inputAttachmentCount )
- , pInputAttachments( rhs.pInputAttachments )
- , colorAttachmentCount( rhs.colorAttachmentCount )
- , pColorAttachments( rhs.pColorAttachments )
- , pResolveAttachments( rhs.pResolveAttachments )
- , pDepthStencilAttachment( rhs.pDepthStencilAttachment )
- , preserveAttachmentCount( rhs.preserveAttachmentCount )
- , pPreserveAttachments( rhs.pPreserveAttachments )
- {}
-
SubpassDescription2 & operator=( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SubpassDescription2 ) - offsetof( SubpassDescription2, pNext ) );
, viewOffset( viewOffset_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassDependency2( SubpassDependency2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , srcSubpass( rhs.srcSubpass )
- , dstSubpass( rhs.dstSubpass )
- , srcStageMask( rhs.srcStageMask )
- , dstStageMask( rhs.dstStageMask )
- , srcAccessMask( rhs.srcAccessMask )
- , dstAccessMask( rhs.dstAccessMask )
- , dependencyFlags( rhs.dependencyFlags )
- , viewOffset( rhs.viewOffset )
- {}
-
SubpassDependency2 & operator=( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SubpassDependency2 ) - offsetof( SubpassDependency2, pNext ) );
, pCorrelatedViewMasks( pCorrelatedViewMasks_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( RenderPassCreateInfo2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , attachmentCount( rhs.attachmentCount )
- , pAttachments( rhs.pAttachments )
- , subpassCount( rhs.subpassCount )
- , pSubpasses( rhs.pSubpasses )
- , dependencyCount( rhs.dependencyCount )
- , pDependencies( rhs.pDependencies )
- , correlatedViewMaskCount( rhs.correlatedViewMaskCount )
- , pCorrelatedViewMasks( rhs.pCorrelatedViewMasks )
- {}
-
RenderPassCreateInfo2 & operator=( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassCreateInfo2 ) - offsetof( RenderPassCreateInfo2, pNext ) );
: fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fragmentDensityMapAttachment( rhs.fragmentDensityMapAttachment )
- {}
-
RenderPassFragmentDensityMapCreateInfoEXT & operator=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) - offsetof( RenderPassFragmentDensityMapCreateInfoEXT, pNext ) );
, pAspectReferences( pAspectReferences_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( RenderPassInputAttachmentAspectCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , aspectReferenceCount( rhs.aspectReferenceCount )
- , pAspectReferences( rhs.pAspectReferences )
- {}
-
RenderPassInputAttachmentAspectCreateInfo & operator=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassInputAttachmentAspectCreateInfo ) - offsetof( RenderPassInputAttachmentAspectCreateInfo, pNext ) );
, pCorrelationMasks( pCorrelationMasks_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( RenderPassMultiviewCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , subpassCount( rhs.subpassCount )
- , pViewMasks( rhs.pViewMasks )
- , dependencyCount( rhs.dependencyCount )
- , pViewOffsets( rhs.pViewOffsets )
- , correlationMaskCount( rhs.correlationMaskCount )
- , pCorrelationMasks( rhs.pCorrelationMasks )
- {}
-
RenderPassMultiviewCreateInfo & operator=( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassMultiviewCreateInfo ) - offsetof( RenderPassMultiviewCreateInfo, pNext ) );
, sampleLocationsInfo( sampleLocationsInfo_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( SubpassSampleLocationsEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : subpassIndex( rhs.subpassIndex )
- , sampleLocationsInfo( rhs.sampleLocationsInfo )
- {}
-
- SubpassSampleLocationsEXT & operator=( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SubpassSampleLocationsEXT ) );
- return *this;
- }
-
SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( RenderPassSampleLocationsBeginInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , attachmentInitialSampleLocationsCount( rhs.attachmentInitialSampleLocationsCount )
- , pAttachmentInitialSampleLocations( rhs.pAttachmentInitialSampleLocations )
- , postSubpassSampleLocationsCount( rhs.postSubpassSampleLocationsCount )
- , pPostSubpassSampleLocations( rhs.pPostSubpassSampleLocations )
- {}
-
RenderPassSampleLocationsBeginInfoEXT & operator=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassSampleLocationsBeginInfoEXT ) - offsetof( RenderPassSampleLocationsBeginInfoEXT, pNext ) );
: transform( transform_ )
{}
- VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( RenderPassTransformBeginInfoQCOM const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , transform( rhs.transform )
- {}
-
RenderPassTransformBeginInfoQCOM & operator=( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassTransformBeginInfoQCOM ) - offsetof( RenderPassTransformBeginInfoQCOM, pNext ) );
, unnormalizedCoordinates( unnormalizedCoordinates_ )
{}
- VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , magFilter( rhs.magFilter )
- , minFilter( rhs.minFilter )
- , mipmapMode( rhs.mipmapMode )
- , addressModeU( rhs.addressModeU )
- , addressModeV( rhs.addressModeV )
- , addressModeW( rhs.addressModeW )
- , mipLodBias( rhs.mipLodBias )
- , anisotropyEnable( rhs.anisotropyEnable )
- , maxAnisotropy( rhs.maxAnisotropy )
- , compareEnable( rhs.compareEnable )
- , compareOp( rhs.compareOp )
- , minLod( rhs.minLod )
- , maxLod( rhs.maxLod )
- , borderColor( rhs.borderColor )
- , unnormalizedCoordinates( rhs.unnormalizedCoordinates )
- {}
-
SamplerCreateInfo & operator=( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SamplerCreateInfo ) - offsetof( SamplerCreateInfo, pNext ) );
: reductionMode( reductionMode_ )
{}
- VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( SamplerReductionModeCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , reductionMode( rhs.reductionMode )
- {}
-
SamplerReductionModeCreateInfo & operator=( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SamplerReductionModeCreateInfo ) - offsetof( SamplerReductionModeCreateInfo, pNext ) );
, forceExplicitReconstruction( forceExplicitReconstruction_ )
{}
- VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( SamplerYcbcrConversionCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , format( rhs.format )
- , ycbcrModel( rhs.ycbcrModel )
- , ycbcrRange( rhs.ycbcrRange )
- , components( rhs.components )
- , xChromaOffset( rhs.xChromaOffset )
- , yChromaOffset( rhs.yChromaOffset )
- , chromaFilter( rhs.chromaFilter )
- , forceExplicitReconstruction( rhs.forceExplicitReconstruction )
- {}
-
SamplerYcbcrConversionCreateInfo & operator=( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SamplerYcbcrConversionCreateInfo ) - offsetof( SamplerYcbcrConversionCreateInfo, pNext ) );
: combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ )
{}
- VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( SamplerYcbcrConversionImageFormatProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , combinedImageSamplerDescriptorCount( rhs.combinedImageSamplerDescriptorCount )
- {}
-
SamplerYcbcrConversionImageFormatProperties & operator=( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SamplerYcbcrConversionImageFormatProperties ) - offsetof( SamplerYcbcrConversionImageFormatProperties, pNext ) );
: conversion( conversion_ )
{}
- VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( SamplerYcbcrConversionInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , conversion( rhs.conversion )
- {}
-
SamplerYcbcrConversionInfo & operator=( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SamplerYcbcrConversionInfo ) - offsetof( SamplerYcbcrConversionInfo, pNext ) );
: flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( SemaphoreCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- {}
-
SemaphoreCreateInfo & operator=( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreCreateInfo ) - offsetof( SemaphoreCreateInfo, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( SemaphoreGetFdInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , semaphore( rhs.semaphore )
- , handleType( rhs.handleType )
- {}
-
SemaphoreGetFdInfoKHR & operator=( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreGetFdInfoKHR ) - offsetof( SemaphoreGetFdInfoKHR, pNext ) );
, handleType( handleType_ )
{}
- VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( SemaphoreGetWin32HandleInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , semaphore( rhs.semaphore )
- , handleType( rhs.handleType )
- {}
-
SemaphoreGetWin32HandleInfoKHR & operator=( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreGetWin32HandleInfoKHR ) - offsetof( SemaphoreGetWin32HandleInfoKHR, pNext ) );
, value( value_ )
{}
- VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( SemaphoreSignalInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , semaphore( rhs.semaphore )
- , value( rhs.value )
- {}
-
SemaphoreSignalInfo & operator=( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreSignalInfo ) - offsetof( SemaphoreSignalInfo, pNext ) );
, initialValue( initialValue_ )
{}
- VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( SemaphoreTypeCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , semaphoreType( rhs.semaphoreType )
- , initialValue( rhs.initialValue )
- {}
-
SemaphoreTypeCreateInfo & operator=( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreTypeCreateInfo ) - offsetof( SemaphoreTypeCreateInfo, pNext ) );
, pValues( pValues_ )
{}
- VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( SemaphoreWaitInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , semaphoreCount( rhs.semaphoreCount )
- , pSemaphores( rhs.pSemaphores )
- , pValues( rhs.pValues )
- {}
-
SemaphoreWaitInfo & operator=( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreWaitInfo ) - offsetof( SemaphoreWaitInfo, pNext ) );
: data( data_ )
{}
- VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( SetStateFlagsIndirectCommandNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : data( rhs.data )
- {}
-
- SetStateFlagsIndirectCommandNV & operator=( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SetStateFlagsIndirectCommandNV ) );
- return *this;
- }
-
SetStateFlagsIndirectCommandNV( VkSetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pCode( pCode_ )
{}
- VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( ShaderModuleCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , codeSize( rhs.codeSize )
- , pCode( rhs.pCode )
- {}
-
ShaderModuleCreateInfo & operator=( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ShaderModuleCreateInfo ) - offsetof( ShaderModuleCreateInfo, pNext ) );
: validationCache( validationCache_ )
{}
- VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , validationCache( rhs.validationCache )
- {}
-
ShaderModuleValidationCacheCreateInfoEXT & operator=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) - offsetof( ShaderModuleValidationCacheCreateInfoEXT, pNext ) );
, scratchMemUsageInBytes( scratchMemUsageInBytes_ )
{}
- VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( ShaderResourceUsageAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : numUsedVgprs( rhs.numUsedVgprs )
- , numUsedSgprs( rhs.numUsedSgprs )
- , ldsSizePerLocalWorkGroup( rhs.ldsSizePerLocalWorkGroup )
- , ldsUsageSizeInBytes( rhs.ldsUsageSizeInBytes )
- , scratchMemUsageInBytes( rhs.scratchMemUsageInBytes )
- {}
-
- ShaderResourceUsageAMD & operator=( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ShaderResourceUsageAMD ) );
- return *this;
- }
-
ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, numPhysicalSgprs( numPhysicalSgprs_ )
, numAvailableVgprs( numAvailableVgprs_ )
, numAvailableSgprs( numAvailableSgprs_ )
- , computeWorkGroupSize{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( computeWorkGroupSize, computeWorkGroupSize_ );
- }
-
- VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( ShaderStatisticsInfoAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : shaderStageMask( rhs.shaderStageMask )
- , resourceUsage( rhs.resourceUsage )
- , numPhysicalVgprs( rhs.numPhysicalVgprs )
- , numPhysicalSgprs( rhs.numPhysicalSgprs )
- , numAvailableVgprs( rhs.numAvailableVgprs )
- , numAvailableSgprs( rhs.numAvailableSgprs )
- , computeWorkGroupSize{}
- {
- VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<uint32_t,3>::copy( computeWorkGroupSize, rhs.computeWorkGroupSize );
- }
-
- ShaderStatisticsInfoAMD & operator=( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( ShaderStatisticsInfoAMD ) );
- return *this;
- }
+ , computeWorkGroupSize( computeWorkGroupSize_ )
+ {}
ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
&& ( numPhysicalSgprs == rhs.numPhysicalSgprs )
&& ( numAvailableVgprs == rhs.numAvailableVgprs )
&& ( numAvailableSgprs == rhs.numAvailableSgprs )
- && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
+ && ( computeWorkGroupSize == rhs.computeWorkGroupSize );
}
bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const VULKAN_HPP_NOEXCEPT
uint32_t numPhysicalSgprs = {};
uint32_t numAvailableVgprs = {};
uint32_t numAvailableSgprs = {};
- uint32_t computeWorkGroupSize[3] = {};
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> computeWorkGroupSize = {};
};
static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ShaderStatisticsInfoAMD>::value, "struct wrapper is not a standard layout!" );
: sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ )
{}
- VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( SharedPresentSurfaceCapabilitiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , sharedPresentSupportedUsageFlags( rhs.sharedPresentSupportedUsageFlags )
- {}
-
SharedPresentSurfaceCapabilitiesKHR & operator=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SharedPresentSurfaceCapabilitiesKHR ) - offsetof( SharedPresentSurfaceCapabilitiesKHR, pNext ) );
, flags( flags_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageFormatProperties( SparseImageFormatProperties const& rhs ) VULKAN_HPP_NOEXCEPT
- : aspectMask( rhs.aspectMask )
- , imageGranularity( rhs.imageGranularity )
- , flags( rhs.flags )
- {}
-
- SparseImageFormatProperties & operator=( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseImageFormatProperties ) );
- return *this;
- }
-
SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: properties( properties_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( SparseImageFormatProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , properties( rhs.properties )
- {}
-
SparseImageFormatProperties2 & operator=( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SparseImageFormatProperties2 ) - offsetof( SparseImageFormatProperties2, pNext ) );
, imageMipTailStride( imageMipTailStride_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( SparseImageMemoryRequirements const& rhs ) VULKAN_HPP_NOEXCEPT
- : formatProperties( rhs.formatProperties )
- , imageMipTailFirstLod( rhs.imageMipTailFirstLod )
- , imageMipTailSize( rhs.imageMipTailSize )
- , imageMipTailOffset( rhs.imageMipTailOffset )
- , imageMipTailStride( rhs.imageMipTailStride )
- {}
-
- SparseImageMemoryRequirements & operator=( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SparseImageMemoryRequirements ) );
- return *this;
- }
-
SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: memoryRequirements( memoryRequirements_ )
{}
- VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( SparseImageMemoryRequirements2 const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , memoryRequirements( rhs.memoryRequirements )
- {}
-
SparseImageMemoryRequirements2 & operator=( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SparseImageMemoryRequirements2 ) - offsetof( SparseImageMemoryRequirements2, pNext ) );
, streamDescriptor( streamDescriptor_ )
{}
- VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateInfoGGP const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , streamDescriptor( rhs.streamDescriptor )
- {}
-
StreamDescriptorSurfaceCreateInfoGGP & operator=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) - offsetof( StreamDescriptorSurfaceCreateInfoGGP, pNext ) );
, size( size_ )
{}
- VULKAN_HPP_CONSTEXPR StridedBufferRegionKHR( StridedBufferRegionKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : buffer( rhs.buffer )
- , offset( rhs.offset )
- , stride( rhs.stride )
- , size( rhs.size )
- {}
-
explicit StridedBufferRegionKHR( IndirectCommandsStreamNV const& indirectCommandsStreamNV,
VULKAN_HPP_NAMESPACE::DeviceSize stride_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} )
, size( size_ )
{}
- StridedBufferRegionKHR & operator=( StridedBufferRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( StridedBufferRegionKHR ) );
- return *this;
- }
-
StridedBufferRegionKHR( VkStridedBufferRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pSignalSemaphores( pSignalSemaphores_ )
{}
- VULKAN_HPP_CONSTEXPR SubmitInfo( SubmitInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , waitSemaphoreCount( rhs.waitSemaphoreCount )
- , pWaitSemaphores( rhs.pWaitSemaphores )
- , pWaitDstStageMask( rhs.pWaitDstStageMask )
- , commandBufferCount( rhs.commandBufferCount )
- , pCommandBuffers( rhs.pCommandBuffers )
- , signalSemaphoreCount( rhs.signalSemaphoreCount )
- , pSignalSemaphores( rhs.pSignalSemaphores )
- {}
-
SubmitInfo & operator=( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SubmitInfo ) - offsetof( SubmitInfo, pNext ) );
: contents( contents_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassBeginInfo( SubpassBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , contents( rhs.contents )
- {}
-
SubpassBeginInfo & operator=( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SubpassBeginInfo ) - offsetof( SubpassBeginInfo, pNext ) );
, pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
{}
- VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( SubpassDescriptionDepthStencilResolve const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , depthResolveMode( rhs.depthResolveMode )
- , stencilResolveMode( rhs.stencilResolveMode )
- , pDepthStencilResolveAttachment( rhs.pDepthStencilResolveAttachment )
- {}
-
SubpassDescriptionDepthStencilResolve & operator=( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SubpassDescriptionDepthStencilResolve ) - offsetof( SubpassDescriptionDepthStencilResolve, pNext ) );
VULKAN_HPP_CONSTEXPR SubpassEndInfo() VULKAN_HPP_NOEXCEPT
{}
- VULKAN_HPP_CONSTEXPR SubpassEndInfo( SubpassEndInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- {}
-
SubpassEndInfo & operator=( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SubpassEndInfo ) - offsetof( SubpassEndInfo, pNext ) );
, supportedSurfaceCounters( supportedSurfaceCounters_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( SurfaceCapabilities2EXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
SurfaceCapabilities2EXT & operator=( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceCapabilities2EXT ) - offsetof( SurfaceCapabilities2EXT, pNext ) );
, supportedUsageFlags( supportedUsageFlags_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( SurfaceCapabilitiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
- SurfaceCapabilitiesKHR & operator=( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SurfaceCapabilitiesKHR ) );
- return *this;
- }
-
SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: surfaceCapabilities( surfaceCapabilities_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( SurfaceCapabilities2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , surfaceCapabilities( rhs.surfaceCapabilities )
- {}
-
SurfaceCapabilities2KHR & operator=( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceCapabilities2KHR ) - offsetof( SurfaceCapabilities2KHR, pNext ) );
: fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( SurfaceCapabilitiesFullScreenExclusiveEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fullScreenExclusiveSupported( rhs.fullScreenExclusiveSupported )
- {}
-
SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) - offsetof( SurfaceCapabilitiesFullScreenExclusiveEXT, pNext ) );
, colorSpace( colorSpace_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( SurfaceFormatKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : format( rhs.format )
- , colorSpace( rhs.colorSpace )
- {}
-
- SurfaceFormatKHR & operator=( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( SurfaceFormatKHR ) );
- return *this;
- }
-
SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
: surfaceFormat( surfaceFormat_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( SurfaceFormat2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , surfaceFormat( rhs.surfaceFormat )
- {}
-
SurfaceFormat2KHR & operator=( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceFormat2KHR ) - offsetof( SurfaceFormat2KHR, pNext ) );
: fullScreenExclusive( fullScreenExclusive_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( SurfaceFullScreenExclusiveInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , fullScreenExclusive( rhs.fullScreenExclusive )
- {}
-
SurfaceFullScreenExclusiveInfoEXT & operator=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceFullScreenExclusiveInfoEXT ) - offsetof( SurfaceFullScreenExclusiveInfoEXT, pNext ) );
: hmonitor( hmonitor_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( SurfaceFullScreenExclusiveWin32InfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , hmonitor( rhs.hmonitor )
- {}
-
SurfaceFullScreenExclusiveWin32InfoEXT & operator=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) - offsetof( SurfaceFullScreenExclusiveWin32InfoEXT, pNext ) );
: supportsProtected( supportsProtected_ )
{}
- VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( SurfaceProtectedCapabilitiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , supportsProtected( rhs.supportsProtected )
- {}
-
SurfaceProtectedCapabilitiesKHR & operator=( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SurfaceProtectedCapabilitiesKHR ) - offsetof( SurfaceProtectedCapabilitiesKHR, pNext ) );
: surfaceCounters( surfaceCounters_ )
{}
- VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( SwapchainCounterCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , surfaceCounters( rhs.surfaceCounters )
- {}
-
SwapchainCounterCreateInfoEXT & operator=( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SwapchainCounterCreateInfoEXT ) - offsetof( SwapchainCounterCreateInfoEXT, pNext ) );
, oldSwapchain( oldSwapchain_ )
{}
- VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( SwapchainCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : 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 )
- {}
-
SwapchainCreateInfoKHR & operator=( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SwapchainCreateInfoKHR ) - offsetof( SwapchainCreateInfoKHR, pNext ) );
: localDimmingEnable( localDimmingEnable_ )
{}
- VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( SwapchainDisplayNativeHdrCreateInfoAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , localDimmingEnable( rhs.localDimmingEnable )
- {}
-
SwapchainDisplayNativeHdrCreateInfoAMD & operator=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) - offsetof( SwapchainDisplayNativeHdrCreateInfoAMD, pNext ) );
: supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ )
{}
- VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( TextureLODGatherFormatPropertiesAMD const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , supportsTextureGatherLODBiasAMD( rhs.supportsTextureGatherLODBiasAMD )
- {}
-
TextureLODGatherFormatPropertiesAMD & operator=( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( TextureLODGatherFormatPropertiesAMD ) - offsetof( TextureLODGatherFormatPropertiesAMD, pNext ) );
, pSignalSemaphoreValues( pSignalSemaphoreValues_ )
{}
- VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( TimelineSemaphoreSubmitInfo const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , waitSemaphoreValueCount( rhs.waitSemaphoreValueCount )
- , pWaitSemaphoreValues( rhs.pWaitSemaphoreValues )
- , signalSemaphoreValueCount( rhs.signalSemaphoreValueCount )
- , pSignalSemaphoreValues( rhs.pSignalSemaphoreValues )
- {}
-
TimelineSemaphoreSubmitInfo & operator=( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( TimelineSemaphoreSubmitInfo ) - offsetof( TimelineSemaphoreSubmitInfo, pNext ) );
, depth( depth_ )
{}
- VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( TraceRaysIndirectCommandKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : width( rhs.width )
- , height( rhs.height )
- , depth( rhs.depth )
- {}
-
explicit TraceRaysIndirectCommandKHR( Extent2D const& extent2D,
uint32_t depth_ = {} )
: width( extent2D.width )
, depth( depth_ )
{}
- TraceRaysIndirectCommandKHR & operator=( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- memcpy( static_cast<void*>(this), &rhs, sizeof( TraceRaysIndirectCommandKHR ) );
- return *this;
- }
-
TraceRaysIndirectCommandKHR( VkTraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = rhs;
, pInitialData( pInitialData_ )
{}
- VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( ValidationCacheCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , initialDataSize( rhs.initialDataSize )
- , pInitialData( rhs.pInitialData )
- {}
-
ValidationCacheCreateInfoEXT & operator=( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ValidationCacheCreateInfoEXT ) - offsetof( ValidationCacheCreateInfoEXT, pNext ) );
, pDisabledValidationFeatures( pDisabledValidationFeatures_ )
{}
- VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( ValidationFeaturesEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , enabledValidationFeatureCount( rhs.enabledValidationFeatureCount )
- , pEnabledValidationFeatures( rhs.pEnabledValidationFeatures )
- , disabledValidationFeatureCount( rhs.disabledValidationFeatureCount )
- , pDisabledValidationFeatures( rhs.pDisabledValidationFeatures )
- {}
-
ValidationFeaturesEXT & operator=( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ValidationFeaturesEXT ) - offsetof( ValidationFeaturesEXT, pNext ) );
, pDisabledValidationChecks( pDisabledValidationChecks_ )
{}
- VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( ValidationFlagsEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , disabledValidationCheckCount( rhs.disabledValidationCheckCount )
- , pDisabledValidationChecks( rhs.pDisabledValidationChecks )
- {}
-
ValidationFlagsEXT & operator=( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ValidationFlagsEXT ) - offsetof( ValidationFlagsEXT, pNext ) );
, window( window_ )
{}
- VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( ViSurfaceCreateInfoNN const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , window( rhs.window )
- {}
-
ViSurfaceCreateInfoNN & operator=( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( ViSurfaceCreateInfoNN ) - offsetof( ViSurfaceCreateInfoNN, pNext ) );
, surface( surface_ )
{}
- VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , display( rhs.display )
- , surface( rhs.surface )
- {}
-
WaylandSurfaceCreateInfoKHR & operator=( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( WaylandSurfaceCreateInfoKHR ) - offsetof( WaylandSurfaceCreateInfoKHR, pNext ) );
, pReleaseKeys( pReleaseKeys_ )
{}
- VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , acquireCount( rhs.acquireCount )
- , pAcquireSyncs( rhs.pAcquireSyncs )
- , pAcquireKeys( rhs.pAcquireKeys )
- , pAcquireTimeouts( rhs.pAcquireTimeouts )
- , releaseCount( rhs.releaseCount )
- , pReleaseSyncs( rhs.pReleaseSyncs )
- , pReleaseKeys( rhs.pReleaseKeys )
- {}
-
Win32KeyedMutexAcquireReleaseInfoKHR & operator=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) - offsetof( Win32KeyedMutexAcquireReleaseInfoKHR, pNext ) );
, pReleaseKeys( pReleaseKeys_ )
{}
- VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , acquireCount( rhs.acquireCount )
- , pAcquireSyncs( rhs.pAcquireSyncs )
- , pAcquireKeys( rhs.pAcquireKeys )
- , pAcquireTimeoutMilliseconds( rhs.pAcquireTimeoutMilliseconds )
- , releaseCount( rhs.releaseCount )
- , pReleaseSyncs( rhs.pReleaseSyncs )
- , pReleaseKeys( rhs.pReleaseKeys )
- {}
-
Win32KeyedMutexAcquireReleaseInfoNV & operator=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) - offsetof( Win32KeyedMutexAcquireReleaseInfoNV, pNext ) );
, hwnd( hwnd_ )
{}
- VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( Win32SurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , hinstance( rhs.hinstance )
- , hwnd( rhs.hwnd )
- {}
-
Win32SurfaceCreateInfoKHR & operator=( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( Win32SurfaceCreateInfoKHR ) - offsetof( Win32SurfaceCreateInfoKHR, pNext ) );
, pTexelBufferView( pTexelBufferView_ )
{}
- VULKAN_HPP_CONSTEXPR WriteDescriptorSet( WriteDescriptorSet const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , dstSet( rhs.dstSet )
- , dstBinding( rhs.dstBinding )
- , dstArrayElement( rhs.dstArrayElement )
- , descriptorCount( rhs.descriptorCount )
- , descriptorType( rhs.descriptorType )
- , pImageInfo( rhs.pImageInfo )
- , pBufferInfo( rhs.pBufferInfo )
- , pTexelBufferView( rhs.pTexelBufferView )
- {}
-
WriteDescriptorSet & operator=( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( WriteDescriptorSet ) - offsetof( WriteDescriptorSet, pNext ) );
, pAccelerationStructures( pAccelerationStructures_ )
{}
- VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( WriteDescriptorSetAccelerationStructureKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , accelerationStructureCount( rhs.accelerationStructureCount )
- , pAccelerationStructures( rhs.pAccelerationStructures )
- {}
-
WriteDescriptorSetAccelerationStructureKHR & operator=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( WriteDescriptorSetAccelerationStructureKHR ) - offsetof( WriteDescriptorSetAccelerationStructureKHR, pNext ) );
, pData( pData_ )
{}
- VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , dataSize( rhs.dataSize )
- , pData( rhs.pData )
- {}
-
WriteDescriptorSetInlineUniformBlockEXT & operator=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) - offsetof( WriteDescriptorSetInlineUniformBlockEXT, pNext ) );
, window( window_ )
{}
- VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( XcbSurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , connection( rhs.connection )
- , window( rhs.window )
- {}
-
XcbSurfaceCreateInfoKHR & operator=( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( XcbSurfaceCreateInfoKHR ) - offsetof( XcbSurfaceCreateInfoKHR, pNext ) );
, window( window_ )
{}
- VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( XlibSurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
- : pNext( rhs.pNext )
- , flags( rhs.flags )
- , dpy( rhs.dpy )
- , window( rhs.window )
- {}
-
XlibSurfaceCreateInfoKHR & operator=( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( &pNext, &rhs.pNext, sizeof( XlibSurfaceCreateInfoKHR ) - offsetof( XlibSurfaceCreateInfoKHR, pNext ) );
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo* pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo* pSubpassBeginInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdBeginRenderPass2( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ) );
+ d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfo & subpassBeginInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdBeginRenderPass2( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ) );
+ d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+ d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+ d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+ d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo* pSubpassEndInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
+ d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
+ d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo* pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo* pSubpassEndInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdNextSubpass2( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
+ d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, const SubpassEndInfo & subpassEndInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdNextSubpass2( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
+ d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
+ d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
+ d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR* pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureKHR*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
+ d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureKHR*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureKHR*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
+ d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureKHR*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const
{
- static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" );
- std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers;
- commandBuffers.reserve( allocateInfo.commandBufferCount );
- CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) );
- Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
+ std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> uniqueCommandBuffers;
+ std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
+ Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>(commandBuffers.data()) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
+ uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
{
- commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) );
+ uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) );
}
}
- return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+ return createResultValue( result, uniqueCommandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" );
- std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers( vectorAllocator );
- commandBuffers.reserve( allocateInfo.commandBufferCount );
- CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) );
- Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
+ std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> uniqueCommandBuffers( vectorAllocator );
+ std::vector<CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
+ Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>(commandBuffers.data()) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
+ uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
{
- commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) );
+ uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffers[i], deleter ) );
}
}
- return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+ return createResultValue( result, uniqueCommandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
}
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const
{
- static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" );
- std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets;
- descriptorSets.reserve( allocateInfo.descriptorSetCount );
- DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) );
- Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
+ std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> uniqueDescriptorSets;
+ std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
+ Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>(descriptorSets.data()) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
+ uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
{
- descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) );
+ uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) );
}
}
- return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
+ return createResultValue( result, uniqueDescriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" );
- std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets( vectorAllocator );
- descriptorSets.reserve( allocateInfo.descriptorSetCount );
- DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) );
- Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
+ std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> uniqueDescriptorSets( vectorAllocator );
+ std::vector<DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
+ Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>(descriptorSets.data()) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
+ uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
{
- descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) );
+ uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSets[i], deleter ) );
}
}
- return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
+ return createResultValue( result, uniqueDescriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
}
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoKHR* pBindInfos, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkBindAccelerationStructureMemoryKHR( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( pBindInfos ) ) );
+ return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoKHR> bindInfos, Dispatch const &d ) const
{
- Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryKHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( bindInfos.data() ) ) );
+ Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
+ return static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
{
- Result result = static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
+ Result result = static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo* pBindInfos, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
+ return static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
{
- Result result = static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
+ Result result = static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines;
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines( vectorAllocator );
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Dispatch>
VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline,Dispatch>> Device::createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
+ return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
- Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
+ Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" );
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
- Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
+ Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
return createResultValue<DescriptorUpdateTemplate,Dispatch>( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHRUnique", deleter );
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines;
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines( vectorAllocator );
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Dispatch>
VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline,Dispatch>> Device::createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesKHR( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines;
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesKHR( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines( vectorAllocator );
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Dispatch>
VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline,Dispatch>> Device::createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines;
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>> Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
- std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
- pipelines.reserve( createInfos.size() );
- Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
- Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+ std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> uniquePipelines( vectorAllocator );
+ std::vector<Pipeline> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>(pipelines.data()) ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{
+ uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+ uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipelines[i], deleter ) );
}
}
- return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+ return createResultValue( result, uniquePipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
template<typename Dispatch>
VULKAN_HPP_INLINE ResultValue<UniqueHandle<Pipeline,Dispatch>> Device::createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2* pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, VULKAN_HPP_NAMESPACE::RenderPass* pRenderPass, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkCreateRenderPass2( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
+ return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::RenderPass renderPass;
- Result result = static_cast<Result>( d.vkCreateRenderPass2( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
+ Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::RenderPass renderPass;
- Result result = static_cast<Result>( d.vkCreateRenderPass2( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
+ Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHRUnique", deleter );
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo* pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
+ return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
- Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
+ Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" );
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
- Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
+ Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
return createResultValue<SamplerYcbcrConversion,Dispatch>( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHRUnique", deleter );
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
- std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs;
- swapchainKHRs.reserve( createInfos.size() );
- SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) );
- Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
+ std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> uniqueSwapchainKHRs;
+ std::vector<SwapchainKHR> swapchainKHRs( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>(swapchainKHRs.data()) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
+ uniqueSwapchainKHRs.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) );
+ uniqueSwapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchainKHRs[i], deleter ) );
}
}
- return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+ return createResultValue( result, uniqueSwapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
}
template<typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
- static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
- std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs( vectorAllocator );
- swapchainKHRs.reserve( createInfos.size() );
- SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) );
- Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
+ std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> uniqueSwapchainKHRs( vectorAllocator );
+ std::vector<SwapchainKHR> swapchainKHRs( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>(swapchainKHRs.data()) ) );
if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
+ uniqueSwapchainKHRs.reserve( createInfos.size() );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
for ( size_t i=0 ; i<createInfos.size() ; i++ )
{
- swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) );
+ uniqueSwapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchainKHRs[i], deleter ) );
}
}
- return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+ return createResultValue( result, uniqueSwapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
}
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkDestroyAccelerationStructureKHR( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+ d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkDestroyAccelerationStructureKHR( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+ d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+ d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+ d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+ d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+ d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
+ return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
+ return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
+ return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
+ return d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2* pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+ d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
- d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+ d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::MemoryRequirements2& memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
- d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+ d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) );
+ return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
+ return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo* pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
+ d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
- d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
+ d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return support;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport& support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
- d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
+ d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
+ d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
- d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
+ d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
return peerMemoryFeatures;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( pInfo ) );
+ return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( pInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- return d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( &info ) );
+ return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( &info ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2* pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+ d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
- d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+ d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::MemoryRequirements2& memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
- d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+ d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
{
std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
- d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
- d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
return sparseMemoryRequirements;
}
template<typename Allocator, typename Dispatch>
{
std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
uint32_t sparseMemoryRequirementCount;
- d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
- d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
return sparseMemoryRequirements;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX* pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+ {
+ return static_cast<Result>( d.vkGetImageViewAddressNVX( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX*>( pProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type Device::getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const &d ) const
+ {
+ VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
+ Result result = static_cast<Result>( d.vkGetImageViewAddressNVX( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX*>( &properties ) ) );
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageViewAddressNVX" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX*>( pInfo ) );
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+ return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename T, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
{
- Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+ Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t* pValue, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
+ return static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const &d ) const
{
uint64_t value;
- Result result = static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
+ Result result = static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreCounterValueKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+ d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+ d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo* pSignalInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( pSignalInfo ) ) );
+ return static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( pSignalInfo ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const &d ) const
{
- Result result = static_cast<Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( &signalInfo ) ) );
+ Result result = static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( &signalInfo ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::signalSemaphoreKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
+ d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
+ d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
+ d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
}
#else
template<typename Dispatch>
VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
- d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
+ d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo* pWaitInfo, uint64_t timeout, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( pWaitInfo ), timeout ) );
+ return static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( pWaitInfo ), timeout ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const &d ) const
{
- Result result = static_cast<Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( &waitInfo ), timeout ) );
+ Result result = static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( &waitInfo ), timeout ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
+ return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
Result result;
do
{
- result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
{
physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
- result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
}
} while ( result == Result::eIncomplete );
if ( result == Result::eSuccess )
Result result;
do
{
- result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
{
physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
- result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
}
} while ( result == Result::eIncomplete );
if ( result == Result::eSuccess )
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
+ d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
- d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
+ d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
return externalBufferProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
+ d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
- d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
+ d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
return externalFenceProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
+ d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
- d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
+ d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
return externalSemaphoreProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
+ d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
- d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
+ d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return features;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2& features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
- d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
+ d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2* pFormatProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
+ d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
- d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+ d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return formatProperties;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::FormatProperties2& formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
- d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+ d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
+ return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
- Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
+ Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::ImageFormatProperties2& imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
- Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
+ Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
+ d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
- d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
+ d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return memoryProperties;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
- d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
+ d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2* pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
+ d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
- d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
+ d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return properties;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
{
StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2& properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
- d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
+ d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
{
std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
uint32_t queueFamilyPropertyCount;
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
return queueFamilyProperties;
}
template<typename Allocator, typename Dispatch>
{
std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
uint32_t queueFamilyPropertyCount;
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
return queueFamilyProperties;
}
template<typename StructureChain, typename Allocator, typename Dispatch>
{
std::vector<StructureChain,Allocator> queueFamilyProperties;
uint32_t queueFamilyPropertyCount;
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
{
localVector[i].pNext = queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
}
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
{
queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = localVector[i];
{
std::vector<StructureChain,Allocator> queueFamilyProperties( vectorAllocator );
uint32_t queueFamilyPropertyCount;
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
{
localVector[i].pNext = queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
}
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
{
queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = localVector[i];
template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2* pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
- d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
{
std::vector<SparseImageFormatProperties2,Allocator> properties;
uint32_t propertyCount;
- d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
properties.resize( propertyCount );
- d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
return properties;
}
template<typename Allocator, typename Dispatch>
{
std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
uint32_t propertyCount;
- d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
properties.resize( propertyCount );
- d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
return properties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0;
PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;
PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
+ PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
#ifdef VK_USE_PLATFORM_ANDROID_KHR
PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
+ vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) );
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
#ifdef VK_USE_PLATFORM_ANDROID_KHR
vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
+ vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
#ifdef VK_USE_PLATFORM_ANDROID_KHR
vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
};
} // namespace VULKAN_HPP_NAMESPACE
+
+namespace std
+{
+ template <> struct hash<vk::AccelerationStructureKHR>
+ {
+ std::size_t operator()(vk::AccelerationStructureKHR const& accelerationStructureKHR) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkAccelerationStructureKHR>{}(static_cast<VkAccelerationStructureKHR>(accelerationStructureKHR));
+ }
+ };
+
+ template <> struct hash<vk::Buffer>
+ {
+ std::size_t operator()(vk::Buffer const& buffer) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkBuffer>{}(static_cast<VkBuffer>(buffer));
+ }
+ };
+
+ template <> struct hash<vk::BufferView>
+ {
+ std::size_t operator()(vk::BufferView const& bufferView) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkBufferView>{}(static_cast<VkBufferView>(bufferView));
+ }
+ };
+
+ template <> struct hash<vk::CommandBuffer>
+ {
+ std::size_t operator()(vk::CommandBuffer const& commandBuffer) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkCommandBuffer>{}(static_cast<VkCommandBuffer>(commandBuffer));
+ }
+ };
+
+ template <> struct hash<vk::CommandPool>
+ {
+ std::size_t operator()(vk::CommandPool const& commandPool) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkCommandPool>{}(static_cast<VkCommandPool>(commandPool));
+ }
+ };
+
+ template <> struct hash<vk::DebugReportCallbackEXT>
+ {
+ std::size_t operator()(vk::DebugReportCallbackEXT const& debugReportCallbackEXT) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDebugReportCallbackEXT>{}(static_cast<VkDebugReportCallbackEXT>(debugReportCallbackEXT));
+ }
+ };
+
+ template <> struct hash<vk::DebugUtilsMessengerEXT>
+ {
+ std::size_t operator()(vk::DebugUtilsMessengerEXT const& debugUtilsMessengerEXT) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDebugUtilsMessengerEXT>{}(static_cast<VkDebugUtilsMessengerEXT>(debugUtilsMessengerEXT));
+ }
+ };
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+ template <> struct hash<vk::DeferredOperationKHR>
+ {
+ std::size_t operator()(vk::DeferredOperationKHR const& deferredOperationKHR) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDeferredOperationKHR>{}(static_cast<VkDeferredOperationKHR>(deferredOperationKHR));
+ }
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ template <> struct hash<vk::DescriptorPool>
+ {
+ std::size_t operator()(vk::DescriptorPool const& descriptorPool) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDescriptorPool>{}(static_cast<VkDescriptorPool>(descriptorPool));
+ }
+ };
+
+ template <> struct hash<vk::DescriptorSet>
+ {
+ std::size_t operator()(vk::DescriptorSet const& descriptorSet) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDescriptorSet>{}(static_cast<VkDescriptorSet>(descriptorSet));
+ }
+ };
+
+ template <> struct hash<vk::DescriptorSetLayout>
+ {
+ std::size_t operator()(vk::DescriptorSetLayout const& descriptorSetLayout) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDescriptorSetLayout>{}(static_cast<VkDescriptorSetLayout>(descriptorSetLayout));
+ }
+ };
+
+ template <> struct hash<vk::DescriptorUpdateTemplate>
+ {
+ std::size_t operator()(vk::DescriptorUpdateTemplate const& descriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDescriptorUpdateTemplate>{}(static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate));
+ }
+ };
+
+ template <> struct hash<vk::Device>
+ {
+ std::size_t operator()(vk::Device const& device) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDevice>{}(static_cast<VkDevice>(device));
+ }
+ };
+
+ template <> struct hash<vk::DeviceMemory>
+ {
+ std::size_t operator()(vk::DeviceMemory const& deviceMemory) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDeviceMemory>{}(static_cast<VkDeviceMemory>(deviceMemory));
+ }
+ };
+
+ template <> struct hash<vk::DisplayKHR>
+ {
+ std::size_t operator()(vk::DisplayKHR const& displayKHR) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDisplayKHR>{}(static_cast<VkDisplayKHR>(displayKHR));
+ }
+ };
+
+ template <> struct hash<vk::DisplayModeKHR>
+ {
+ std::size_t operator()(vk::DisplayModeKHR const& displayModeKHR) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkDisplayModeKHR>{}(static_cast<VkDisplayModeKHR>(displayModeKHR));
+ }
+ };
+
+ template <> struct hash<vk::Event>
+ {
+ std::size_t operator()(vk::Event const& event) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkEvent>{}(static_cast<VkEvent>(event));
+ }
+ };
+
+ template <> struct hash<vk::Fence>
+ {
+ std::size_t operator()(vk::Fence const& fence) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkFence>{}(static_cast<VkFence>(fence));
+ }
+ };
+
+ template <> struct hash<vk::Framebuffer>
+ {
+ std::size_t operator()(vk::Framebuffer const& framebuffer) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkFramebuffer>{}(static_cast<VkFramebuffer>(framebuffer));
+ }
+ };
+
+ template <> struct hash<vk::Image>
+ {
+ std::size_t operator()(vk::Image const& image) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkImage>{}(static_cast<VkImage>(image));
+ }
+ };
+
+ template <> struct hash<vk::ImageView>
+ {
+ std::size_t operator()(vk::ImageView const& imageView) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkImageView>{}(static_cast<VkImageView>(imageView));
+ }
+ };
+
+ template <> struct hash<vk::IndirectCommandsLayoutNV>
+ {
+ std::size_t operator()(vk::IndirectCommandsLayoutNV const& indirectCommandsLayoutNV) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkIndirectCommandsLayoutNV>{}(static_cast<VkIndirectCommandsLayoutNV>(indirectCommandsLayoutNV));
+ }
+ };
+
+ template <> struct hash<vk::Instance>
+ {
+ std::size_t operator()(vk::Instance const& instance) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkInstance>{}(static_cast<VkInstance>(instance));
+ }
+ };
+
+ template <> struct hash<vk::PerformanceConfigurationINTEL>
+ {
+ std::size_t operator()(vk::PerformanceConfigurationINTEL const& performanceConfigurationINTEL) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkPerformanceConfigurationINTEL>{}(static_cast<VkPerformanceConfigurationINTEL>(performanceConfigurationINTEL));
+ }
+ };
+
+ template <> struct hash<vk::PhysicalDevice>
+ {
+ std::size_t operator()(vk::PhysicalDevice const& physicalDevice) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkPhysicalDevice>{}(static_cast<VkPhysicalDevice>(physicalDevice));
+ }
+ };
+
+ template <> struct hash<vk::Pipeline>
+ {
+ std::size_t operator()(vk::Pipeline const& pipeline) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkPipeline>{}(static_cast<VkPipeline>(pipeline));
+ }
+ };
+
+ template <> struct hash<vk::PipelineCache>
+ {
+ std::size_t operator()(vk::PipelineCache const& pipelineCache) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkPipelineCache>{}(static_cast<VkPipelineCache>(pipelineCache));
+ }
+ };
+
+ template <> struct hash<vk::PipelineLayout>
+ {
+ std::size_t operator()(vk::PipelineLayout const& pipelineLayout) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkPipelineLayout>{}(static_cast<VkPipelineLayout>(pipelineLayout));
+ }
+ };
+
+ template <> struct hash<vk::QueryPool>
+ {
+ std::size_t operator()(vk::QueryPool const& queryPool) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkQueryPool>{}(static_cast<VkQueryPool>(queryPool));
+ }
+ };
+
+ template <> struct hash<vk::Queue>
+ {
+ std::size_t operator()(vk::Queue const& queue) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkQueue>{}(static_cast<VkQueue>(queue));
+ }
+ };
+
+ template <> struct hash<vk::RenderPass>
+ {
+ std::size_t operator()(vk::RenderPass const& renderPass) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkRenderPass>{}(static_cast<VkRenderPass>(renderPass));
+ }
+ };
+
+ template <> struct hash<vk::Sampler>
+ {
+ std::size_t operator()(vk::Sampler const& sampler) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkSampler>{}(static_cast<VkSampler>(sampler));
+ }
+ };
+
+ template <> struct hash<vk::SamplerYcbcrConversion>
+ {
+ std::size_t operator()(vk::SamplerYcbcrConversion const& samplerYcbcrConversion) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkSamplerYcbcrConversion>{}(static_cast<VkSamplerYcbcrConversion>(samplerYcbcrConversion));
+ }
+ };
+
+ template <> struct hash<vk::Semaphore>
+ {
+ std::size_t operator()(vk::Semaphore const& semaphore) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkSemaphore>{}(static_cast<VkSemaphore>(semaphore));
+ }
+ };
+
+ template <> struct hash<vk::ShaderModule>
+ {
+ std::size_t operator()(vk::ShaderModule const& shaderModule) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkShaderModule>{}(static_cast<VkShaderModule>(shaderModule));
+ }
+ };
+
+ template <> struct hash<vk::SurfaceKHR>
+ {
+ std::size_t operator()(vk::SurfaceKHR const& surfaceKHR) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkSurfaceKHR>{}(static_cast<VkSurfaceKHR>(surfaceKHR));
+ }
+ };
+
+ template <> struct hash<vk::SwapchainKHR>
+ {
+ std::size_t operator()(vk::SwapchainKHR const& swapchainKHR) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkSwapchainKHR>{}(static_cast<VkSwapchainKHR>(swapchainKHR));
+ }
+ };
+
+ template <> struct hash<vk::ValidationCacheEXT>
+ {
+ std::size_t operator()(vk::ValidationCacheEXT const& validationCacheEXT) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::hash<VkValidationCacheEXT>{}(static_cast<VkValidationCacheEXT>(validationCacheEXT));
+ }
+ };
+}
#endif
{
"version info": {
"schema version": 2,
- "api version": "1.2.136",
- "comment": "from git branch: github-master commit: 9d2243151f9d7a1ed0b37424ab74c1416c7d903c",
- "date": "2020-03-24 15:02:01Z"
+ "api version": "1.2.137",
+ "comment": "from git branch: github-master commit: 019f62b11de9358d3383ead2e1a8c5bc2fda23ad",
+ "date": "2020-04-07 05:14:56Z"
},
"validation": {
"vkGetInstanceProcAddr": {
"core": [
{
"vuid": "VUID-vkCreateInstance-ppEnabledExtensionNames-01388",
- "text": " All <a href=\"#extendingvulkan-extensions-extensiondependencies\">required extensions</a> for each extension in the <a href=\"#VkInstanceCreateInfo\">VkInstanceCreateInfo</a>::<code>ppEnabledExtensionNames</code> list <strong class=\"purple\">must</strong> also be present in that list."
+ "text": " All <a href=\"#extendingvulkan-extensions-extensiondependencies\">required extensions</a> for each extension in the <a href=\"#VkInstanceCreateInfo\">VkInstanceCreateInfo</a>::<code>ppEnabledExtensionNames</code> list <strong class=\"purple\">must</strong> also be present in that list"
},
{
"vuid": "VUID-vkCreateInstance-pCreateInfo-parameter",
"VkValidationFeaturesEXT": {
"(VK_EXT_validation_features)": [
{
+ "vuid": "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-02967",
+ "text": " If the <code>pEnabledValidationFeatures</code> array contains <code>VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT</code>, then it <strong class=\"purple\">must</strong> also contain <code>VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT</code>"
+ },
+ {
+ "vuid": "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-02968",
+ "text": " If the <code>pEnabledValidationFeatures</code> array contains <code>VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT</code>, then it <strong class=\"purple\">must</strong> not contain <code>VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT</code>"
+ },
+ {
"vuid": "VUID-VkValidationFeaturesEXT-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT</code>"
},
{
"vuid": "VUID-VkPhysicalDeviceVulkan11Properties-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES</code>"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan11Properties-pointClippingBehavior-parameter",
- "text": " <code>pointClippingBehavior</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPointClippingBehavior\">VkPointClippingBehavior</a> value"
}
]
},
{
"vuid": "VUID-VkPhysicalDeviceVulkan12Properties-sType-sType",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES</code>"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-driverID-parameter",
- "text": " <code>driverID</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDriverId\">VkDriverId</a> value"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-driverName-parameter",
- "text": " <code>driverName</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DRIVER_NAME_SIZE"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-driverInfo-parameter",
- "text": " <code>driverInfo</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DRIVER_INFO_SIZE"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-denormBehaviorIndependence-parameter",
- "text": " <code>denormBehaviorIndependence</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkShaderFloatControlsIndependence\">VkShaderFloatControlsIndependence</a> value"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-roundingModeIndependence-parameter",
- "text": " <code>roundingModeIndependence</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkShaderFloatControlsIndependence\">VkShaderFloatControlsIndependence</a> value"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-supportedDepthResolveModes-parameter",
- "text": " <code>supportedDepthResolveModes</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkResolveModeFlagBits\">VkResolveModeFlagBits</a> values"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-supportedDepthResolveModes-requiredbitmask",
- "text": " <code>supportedDepthResolveModes</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-supportedStencilResolveModes-parameter",
- "text": " <code>supportedStencilResolveModes</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkResolveModeFlagBits\">VkResolveModeFlagBits</a> values"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-supportedStencilResolveModes-requiredbitmask",
- "text": " <code>supportedStencilResolveModes</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
- },
- {
- "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-framebufferIntegerColorSampleCounts-parameter",
- "text": " <code>framebufferIntegerColorSampleCounts</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkSampleCountFlagBits\">VkSampleCountFlagBits</a> values"
}
]
},
"core": [
{
"vuid": "VUID-vkCreateDevice-ppEnabledExtensionNames-01387",
- "text": " All <a href=\"#extendingvulkan-extensions-extensiondependencies\">required extensions</a> for each extension in the <a href=\"#VkDeviceCreateInfo\">VkDeviceCreateInfo</a>::<code>ppEnabledExtensionNames</code> list <strong class=\"purple\">must</strong> also be present in that list."
+ "text": " All <a href=\"#extendingvulkan-extensions-extensiondependencies\">required extensions</a> for each extension in the <a href=\"#VkDeviceCreateInfo\">VkDeviceCreateInfo</a>::<code>ppEnabledExtensionNames</code> list <strong class=\"purple\">must</strong> also be present in that list"
},
{
"vuid": "VUID-vkCreateDevice-physicalDevice-parameter",
},
{
"vuid": "VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377",
- "text": " If <code>physicalDeviceCount</code> is not <code>0</code>, the <code>physicalDevice</code> parameter of <a href=\"#vkCreateDevice\">vkCreateDevice</a> <strong class=\"purple\">must</strong> be an element of <code>pPhysicalDevices</code>."
+ "text": " If <code>physicalDeviceCount</code> is not <code>0</code>, the <code>physicalDevice</code> parameter of <a href=\"#vkCreateDevice\">vkCreateDevice</a> <strong class=\"purple\">must</strong> be an element of <code>pPhysicalDevices</code>"
},
{
"vuid": "VUID-VkDeviceGroupDeviceCreateInfo-sType-sType",
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-VkDeviceQueueCreateInfo-flags-02861",
- "text": " If the <a href=\"#features-protectedMemory\">protected memory</a> feature is not enabled, the <code>VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT</code> bit of <code>flags</code> <strong class=\"purple\">must</strong> not be set."
+ "text": " If the <a href=\"#features-protectedMemory\">protected memory</a> feature is not enabled, the <code>VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT</code> bit of <code>flags</code> <strong class=\"purple\">must</strong> not be set"
}
]
},
"core": [
{
"vuid": "VUID-vkGetDeviceQueue-queueFamilyIndex-00384",
- "text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be one of the queue family indices specified when <code>device</code> was created, via the <code>VkDeviceQueueCreateInfo</code> structure"
+ "text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be one of the queue family indices specified when <code>device</code> was created, via the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
},
{
"vuid": "VUID-vkGetDeviceQueue-queueIndex-00385",
- "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index when <code>device</code> was created, via the <code>queueCount</code> member of the <code>VkDeviceQueueCreateInfo</code> structure"
+ "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index when <code>device</code> was created, via the <code>queueCount</code> member of the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
},
{
"vuid": "VUID-vkGetDeviceQueue-flags-01841",
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842",
- "text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be one of the queue family indices specified when <code>device</code> was created, via the <code>VkDeviceQueueCreateInfo</code> structure"
+ "text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be one of the queue family indices specified when <code>device</code> was created, via the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
},
{
"vuid": "VUID-VkDeviceQueueInfo2-queueIndex-01843",
- "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index and <a href=\"#VkDeviceQueueCreateFlags\">VkDeviceQueueCreateFlags</a> member <code>flags</code> equal to this <code>flags</code> value when <code>device</code> was created, via the <code>queueCount</code> member of the <code>VkDeviceQueueCreateInfo</code> structure"
+ "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index and <a href=\"#VkDeviceQueueCreateFlags\">VkDeviceQueueCreateFlags</a> member <code>flags</code> equal to this <code>flags</code> value when <code>device</code> was created, via the <code>queueCount</code> member of the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
},
{
"vuid": "VUID-VkDeviceQueueInfo2-sType-sType",
"core": [
{
"vuid": "VUID-vkCreateCommandPool-queueFamilyIndex-01937",
- "text": " <code>pCreateInfo->queueFamilyIndex</code> <strong class=\"purple\">must</strong> be the index of a queue family available in the logical device <code>device</code>."
+ "text": " <code>pCreateInfo->queueFamilyIndex</code> <strong class=\"purple\">must</strong> be the index of a queue family available in the logical device <code>device</code>"
},
{
"vuid": "VUID-vkCreateCommandPool-device-parameter",
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-VkCommandPoolCreateInfo-flags-02860",
- "text": " If the protected memory feature is not enabled, the <code>VK_COMMAND_POOL_CREATE_PROTECTED_BIT</code> bit of <code>flags</code> <strong class=\"purple\">must</strong> not be set."
+ "text": " If the protected memory feature is not enabled, the <code>VK_COMMAND_POOL_CREATE_PROTECTED_BIT</code> bit of <code>flags</code> <strong class=\"purple\">must</strong> not be set"
}
],
"core": [
"core": [
{
"vuid": "VUID-vkDestroyCommandPool-commandPool-00041",
- "text": " All <code>VkCommandBuffer</code> objects allocated from <code>commandPool</code> <strong class=\"purple\">must</strong> not be in the <a href=\"#commandbuffers-lifecycle\">pending state</a>."
+ "text": " All <code>VkCommandBuffer</code> objects allocated from <code>commandPool</code> <strong class=\"purple\">must</strong> not be in the <a href=\"#commandbuffers-lifecycle\">pending state</a>"
},
{
"vuid": "VUID-vkDestroyCommandPool-commandPool-00042",
"(VK_QCOM_render_pass_transform)": [
{
"vuid": "VUID-VkCommandBufferInheritanceRenderPassTransformInfoQCOM-transform-02864",
- "text": " <code>transform</code> <strong class=\"purple\">must</strong> be VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, or VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR."
+ "text": " <code>transform</code> <strong class=\"purple\">must</strong> be <code>VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR</code>, <code>VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR</code>, <code>VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR</code>, or <code>VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR</code>"
},
{
"vuid": "VUID-VkCommandBufferInheritanceRenderPassTransformInfoQCOM-sType-sType",
"core": [
{
"vuid": "VUID-vkEndCommandBuffer-commandBuffer-00059",
- "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>."
+ "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
},
{
"vuid": "VUID-vkEndCommandBuffer-commandBuffer-00060",
"(VK_EXT_debug_utils)": [
{
"vuid": "VUID-vkEndCommandBuffer-commandBuffer-01815",
- "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> not be an outstanding <a href=\"#vkCmdBeginDebugUtilsLabelEXT\">vkCmdBeginDebugUtilsLabelEXT</a> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <a href=\"#vkCmdEndDebugUtilsLabelEXT\">vkCmdEndDebugUtilsLabelEXT</a>."
+ "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> not be an outstanding <a href=\"#vkCmdBeginDebugUtilsLabelEXT\">vkCmdBeginDebugUtilsLabelEXT</a> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <a href=\"#vkCmdEndDebugUtilsLabelEXT\">vkCmdEndDebugUtilsLabelEXT</a>"
}
],
"(VK_EXT_debug_marker)": [
{
"vuid": "VUID-vkEndCommandBuffer-commandBuffer-00062",
- "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> not be an outstanding <a href=\"#vkCmdDebugMarkerBeginEXT\">vkCmdDebugMarkerBeginEXT</a> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <a href=\"#vkCmdDebugMarkerEndEXT\">vkCmdDebugMarkerEndEXT</a>."
+ "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> not be an outstanding <a href=\"#vkCmdDebugMarkerBeginEXT\">vkCmdDebugMarkerBeginEXT</a> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <a href=\"#vkCmdDebugMarkerEndEXT\">vkCmdDebugMarkerEndEXT</a>"
}
]
},
},
{
"vuid": "VUID-VkSubmitInfo-pWaitSemaphores-03243",
- "text": " For each element of <code>pWaitSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pWaitSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>."
+ "text": " For each element of <code>pWaitSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pWaitSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>"
},
{
"vuid": "VUID-VkSubmitInfo-pSignalSemaphores-03244",
- "text": " For each element of <code>pSignalSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pSignalSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>."
+ "text": " For each element of <code>pSignalSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pSignalSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>"
}
],
"(VK_NV_mesh_shader)": [
"(VK_KHR_external_semaphore_win32)": [
{
"vuid": "VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079",
- "text": " <code>waitSemaphoreValuesCount</code> <strong class=\"purple\">must</strong> be the same value as <code>VkSubmitInfo</code>::<code>waitSemaphoreCount</code>, where <code>VkSubmitInfo</code> is in the <code>pNext</code> chain of this <code>VkD3D12FenceSubmitInfoKHR</code> structure."
+ "text": " <code>waitSemaphoreValuesCount</code> <strong class=\"purple\">must</strong> be the same value as <code>VkSubmitInfo</code>::<code>waitSemaphoreCount</code>, where <code>VkSubmitInfo</code> is in the <code>pNext</code> chain of this <code>VkD3D12FenceSubmitInfoKHR</code> structure"
},
{
"vuid": "VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080",
- "text": " <code>signalSemaphoreValuesCount</code> <strong class=\"purple\">must</strong> be the same value as <code>VkSubmitInfo</code>::<code>signalSemaphoreCount</code>, where <code>VkSubmitInfo</code> is in the <code>pNext</code> chain of this <code>VkD3D12FenceSubmitInfoKHR</code> structure."
+ "text": " <code>signalSemaphoreValuesCount</code> <strong class=\"purple\">must</strong> be the same value as <code>VkSubmitInfo</code>::<code>signalSemaphoreCount</code>, where <code>VkSubmitInfo</code> is in the <code>pNext</code> chain of this <code>VkD3D12FenceSubmitInfoKHR</code> structure"
},
{
"vuid": "VUID-VkD3D12FenceSubmitInfoKHR-sType-sType",
"(VK_KHR_win32_keyed_mutex)": [
{
"vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081",
- "text": " Each member of <code>pAcquireSyncs</code> and <code>pReleaseSyncs</code> <strong class=\"purple\">must</strong> be a device memory object imported by setting <a href=\"#VkImportMemoryWin32HandleInfoKHR\">VkImportMemoryWin32HandleInfoKHR</a>::<code>handleType</code> to <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code> or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>."
+ "text": " Each member of <code>pAcquireSyncs</code> and <code>pReleaseSyncs</code> <strong class=\"purple\">must</strong> be a device memory object imported by setting <a href=\"#VkImportMemoryWin32HandleInfoKHR\">VkImportMemoryWin32HandleInfoKHR</a>::<code>handleType</code> to <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code> or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>"
},
{
"vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType",
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01816",
- "text": " If the protected memory feature is not enabled, <code>protectedSubmit</code> <strong class=\"purple\">must</strong> not be <code>VK_TRUE</code>."
+ "text": " If the protected memory feature is not enabled, <code>protectedSubmit</code> <strong class=\"purple\">must</strong> not be <code>VK_TRUE</code>"
},
{
"vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01817",
- "text": " If <code>protectedSubmit</code> is <code>VK_TRUE</code>, then each element of the <code>pCommandBuffers</code> array <strong class=\"purple\">must</strong> be a protected command buffer."
+ "text": " If <code>protectedSubmit</code> is <code>VK_TRUE</code>, then each element of the <code>pCommandBuffers</code> array <strong class=\"purple\">must</strong> be a protected command buffer"
},
{
"vuid": "VUID-VkProtectedSubmitInfo-protectedSubmit-01818",
- "text": " If <code>protectedSubmit</code> is <code>VK_FALSE</code>, then each element of the <code>pCommandBuffers</code> array <strong class=\"purple\">must</strong> be an unprotected command buffer."
+ "text": " If <code>protectedSubmit</code> is <code>VK_FALSE</code>, then each element of the <code>pCommandBuffers</code> array <strong class=\"purple\">must</strong> be an unprotected command buffer"
},
{
"vuid": "VUID-VkProtectedSubmitInfo-pNext-01819",
- "text": " If the <code>VkSubmitInfo</code>::<code>pNext</code> chain does not include a <code>VkProtectedSubmitInfo</code> structure, then each element of the command buffer of the <code>pCommandBuffers</code> array <strong class=\"purple\">must</strong> be an unprotected command buffer."
+ "text": " If the <code>VkSubmitInfo</code>::<code>pNext</code> chain does not include a <code>VkProtectedSubmitInfo</code> structure, then each element of the command buffer of the <code>pCommandBuffers</code> array <strong class=\"purple\">must</strong> be an unprotected command buffer"
},
{
"vuid": "VUID-VkProtectedSubmitInfo-sType-sType",
"(VK_QCOM_render_pass_transform)": [
{
"vuid": "VUID-vkCmdExecuteCommands-pNext-02865",
- "text": " If <code>vkCmdExecuteCommands</code> is being called within a render pass instance that included <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a> in the <code>pNext</code> chain of <a href=\"#VkRenderPassBeginInfo\">VkRenderPassBeginInfo</a>, then each element of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> have been recorded with <a href=\"#VkCommandBufferInheritanceRenderPassTransformInfoQCOM\">VkCommandBufferInheritanceRenderPassTransformInfoQCOM</a> in the <code>pNext</code> chain of VkCommandBufferBeginInfo"
+ "text": " If <code>vkCmdExecuteCommands</code> is being called within a render pass instance that included <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a> in the <code>pNext</code> chain of <a href=\"#VkRenderPassBeginInfo\">VkRenderPassBeginInfo</a>, then each element of <code>pCommandBuffers</code> <strong class=\"purple\">must</strong> have been recorded with <a href=\"#VkCommandBufferInheritanceRenderPassTransformInfoQCOM\">VkCommandBufferInheritanceRenderPassTransformInfoQCOM</a> in the <code>pNext</code> chain of <a href=\"#VkCommandBufferBeginInfo\">VkCommandBufferBeginInfo</a>"
},
{
"vuid": "VUID-vkCmdExecuteCommands-pNext-02866",
},
{
"vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00110",
- "text": " <code>deviceMask</code> <strong class=\"purple\">must</strong> not include any set bits that were not in the <a href=\"#VkDeviceGroupCommandBufferBeginInfo\">VkDeviceGroupCommandBufferBeginInfo</a>::<code>deviceMask</code> value when the command buffer began recording."
+ "text": " <code>deviceMask</code> <strong class=\"purple\">must</strong> not include any set bits that were not in the <a href=\"#VkDeviceGroupCommandBufferBeginInfo\">VkDeviceGroupCommandBufferBeginInfo</a>::<code>deviceMask</code> value when the command buffer began recording"
},
{
"vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00111",
- "text": " If <code>vkCmdSetDeviceMask</code> is called inside a render pass instance, <code>deviceMask</code> <strong class=\"purple\">must</strong> not include any set bits that were not in the <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>::<code>deviceMask</code> value when the render pass instance began recording."
+ "text": " If <code>vkCmdSetDeviceMask</code> is called inside a render pass instance, <code>deviceMask</code> <strong class=\"purple\">must</strong> not include any set bits that were not in the <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>::<code>deviceMask</code> value when the render pass instance began recording"
},
{
"vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-parameter",
"(VK_VERSION_1_1,VK_KHR_external_fence)": [
{
"vuid": "VUID-VkExportFenceCreateInfo-handleTypes-01446",
- "text": " The bits in <code>handleTypes</code> must be supported and compatible, as reported by <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>."
+ "text": " The bits in <code>handleTypes</code> must be supported and compatible, as reported by <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>"
},
{
"vuid": "VUID-VkExportFenceCreateInfo-sType-sType",
"(VK_KHR_external_fence_win32)": [
{
"vuid": "VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447",
- "text": " If <a href=\"#VkExportFenceCreateInfo\">VkExportFenceCreateInfo</a>::<code>handleTypes</code> does not include <code>VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, a <code>VkExportFenceWin32HandleInfoKHR</code> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of <a href=\"#VkFenceCreateInfo\">VkFenceCreateInfo</a>."
+ "text": " If <a href=\"#VkExportFenceCreateInfo\">VkExportFenceCreateInfo</a>::<code>handleTypes</code> does not include <code>VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, a <code>VkExportFenceWin32HandleInfoKHR</code> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of <a href=\"#VkFenceCreateInfo\">VkFenceCreateInfo</a>"
},
{
"vuid": "VUID-VkExportFenceWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_fence_win32)": [
{
"vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportFenceCreateInfo\">VkExportFenceCreateInfo</a>::<code>handleTypes</code> when the <code>fence</code>’s current payload was created."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportFenceCreateInfo\">VkExportFenceCreateInfo</a>::<code>handleTypes</code> when the <code>fence</code>’s current payload was created"
},
{
"vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449",
- "text": " If <code>handleType</code> is defined as an NT handle, <a href=\"#vkGetFenceWin32HandleKHR\">vkGetFenceWin32HandleKHR</a> <strong class=\"purple\">must</strong> be called no more than once for each valid unique combination of <code>fence</code> and <code>handleType</code>."
+ "text": " If <code>handleType</code> is defined as an NT handle, <a href=\"#vkGetFenceWin32HandleKHR\">vkGetFenceWin32HandleKHR</a> <strong class=\"purple\">must</strong> be called no more than once for each valid unique combination of <code>fence</code> and <code>handleType</code>"
},
{
"vuid": "VUID-VkFenceGetWin32HandleInfoKHR-fence-01450",
- "text": " <code>fence</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-fences-importing\">Importing Fence Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>."
+ "text": " <code>fence</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-fences-importing\">Importing Fence Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>"
},
{
"vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>fence</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-fences-signaling\">fence signal operation</a> pending execution."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>fence</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-fences-signaling\">fence signal operation</a> pending execution"
},
{
"vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle"
},
{
"vuid": "VUID-VkFenceGetWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_fence_fd)": [
{
"vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01453",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportFenceCreateInfo\">VkExportFenceCreateInfo</a>::<code>handleTypes</code> when <code>fence</code>’s current payload was created."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportFenceCreateInfo\">VkExportFenceCreateInfo</a>::<code>handleTypes</code> when <code>fence</code>’s current payload was created"
},
{
"vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01454",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>fence</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-fences-signaling\">fence signal operation</a> pending execution."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>fence</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-fences-signaling\">fence signal operation</a> pending execution"
},
{
"vuid": "VUID-VkFenceGetFdInfoKHR-fence-01455",
- "text": " <code>fence</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-fences-importing\">Importing Fence Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>."
+ "text": " <code>fence</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-fences-importing\">Importing Fence Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalFenceProperties\">VkExternalFenceProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>"
},
{
"vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01456",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle"
},
{
"vuid": "VUID-VkFenceGetFdInfoKHR-sType-sType",
"(VK_KHR_external_fence_win32)": [
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-fence-handletypes-win32\">Handle Types Supported by VkImportFenceWin32HandleInfoKHR</a> table."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-fence-handletypes-win32\">Handle Types Supported by <code>VkImportFenceWin32HandleInfoKHR</code></a> table"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459",
- "text": " If <code>handleType</code> is not <code>VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>."
+ "text": " If <code>handleType</code> is not <code>VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460",
- "text": " If <code>handleType</code> is not <code>0</code> and <code>handle</code> is <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> name a valid synchronization primitive of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code> and <code>handle</code> is <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> name a valid synchronization primitive of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461",
- "text": " If <code>handleType</code> is not <code>0</code> and <code>name</code> is <code>NULL</code>, <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code> and <code>name</code> is <code>NULL</code>, <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01462",
- "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>."
+ "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01539",
- "text": " If <code>handle</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-fence-handle-types-compatibility\">external fence handle types compatibility</a>."
+ "text": " If <code>handle</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-fence-handle-types-compatibility\">external fence handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-name-01540",
- "text": " If <code>name</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-fence-handle-types-compatibility\">external fence handle types compatibility</a>."
+ "text": " If <code>name</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-fence-handle-types-compatibility\">external fence handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportFenceWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_fence_fd)": [
{
"vuid": "VUID-VkImportFenceFdInfoKHR-handleType-01464",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-fence-handletypes-fd\">Handle Types Supported by VkImportFenceFdInfoKHR</a> table."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-fence-handletypes-fd\">Handle Types Supported by <code>VkImportFenceFdInfoKHR</code></a> table"
},
{
"vuid": "VUID-VkImportFenceFdInfoKHR-fd-01541",
- "text": " <code>fd</code> <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-fence-handle-types-compatibility\">external fence handle types compatibility</a>."
+ "text": " <code>fd</code> <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-fence-handle-types-compatibility\">external fence handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportFenceFdInfoKHR-sType-sType",
},
{
"vuid": "VUID-VkSemaphoreTypeCreateInfo-semaphoreType-03279",
- "text": " If <code>semaphoreType</code> is <code>VK_SEMAPHORE_TYPE_BINARY</code>, <code>initialValue</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If <code>semaphoreType</code> is <code>VK_SEMAPHORE_TYPE_BINARY</code>, <code>initialValue</code> <strong class=\"purple\">must</strong> be zero"
}
]
},
"(VK_VERSION_1_1,VK_KHR_external_semaphore)": [
{
"vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-01124",
- "text": " The bits in <code>handleTypes</code> <strong class=\"purple\">must</strong> be supported and compatible, as reported by <a href=\"#VkExternalSemaphoreProperties\">VkExternalSemaphoreProperties</a>."
+ "text": " The bits in <code>handleTypes</code> <strong class=\"purple\">must</strong> be supported and compatible, as reported by <a href=\"#VkExternalSemaphoreProperties\">VkExternalSemaphoreProperties</a>"
},
{
"vuid": "VUID-VkExportSemaphoreCreateInfo-sType-sType",
"(VK_KHR_external_semaphore_win32)": [
{
"vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125",
- "text": " If <a href=\"#VkExportSemaphoreCreateInfo\">VkExportSemaphoreCreateInfo</a>::<code>handleTypes</code> does not include <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT</code>, <code>VkExportSemaphoreWin32HandleInfoKHR</code> <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of <a href=\"#VkSemaphoreCreateInfo\">VkSemaphoreCreateInfo</a>."
+ "text": " If <a href=\"#VkExportSemaphoreCreateInfo\">VkExportSemaphoreCreateInfo</a>::<code>handleTypes</code> does not include <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT</code>, <code>VkExportSemaphoreWin32HandleInfoKHR</code> <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of <a href=\"#VkSemaphoreCreateInfo\">VkSemaphoreCreateInfo</a>"
},
{
"vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_semaphore_win32)": [
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportSemaphoreCreateInfo\">VkExportSemaphoreCreateInfo</a>::<code>handleTypes</code> when the <code>semaphore</code>’s current payload was created."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportSemaphoreCreateInfo\">VkExportSemaphoreCreateInfo</a>::<code>handleTypes</code> when the <code>semaphore</code>’s current payload was created"
},
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127",
- "text": " If <code>handleType</code> is defined as an NT handle, <a href=\"#vkGetSemaphoreWin32HandleKHR\">vkGetSemaphoreWin32HandleKHR</a> <strong class=\"purple\">must</strong> be called no more than once for each valid unique combination of <code>semaphore</code> and <code>handleType</code>."
+ "text": " If <code>handleType</code> is defined as an NT handle, <a href=\"#vkGetSemaphoreWin32HandleKHR\">vkGetSemaphoreWin32HandleKHR</a> <strong class=\"purple\">must</strong> be called no more than once for each valid unique combination of <code>semaphore</code> and <code>handleType</code>"
},
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128",
- "text": " <code>semaphore</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalSemaphoreProperties\">VkExternalSemaphoreProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>."
+ "text": " <code>semaphore</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalSemaphoreProperties\">VkExternalSemaphoreProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>"
},
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, as defined below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a>, there <strong class=\"purple\">must</strong> be no queue waiting on <code>semaphore</code>."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, as defined below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a>, there <strong class=\"purple\">must</strong> be no queue waiting on <code>semaphore</code>"
},
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-semaphores-signaling\">semaphore signal operation</a> pending execution."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-semaphores-signaling\">semaphore signal operation</a> pending execution"
},
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle"
},
{
"vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_semaphore_fd)": [
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01132",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportSemaphoreCreateInfo\">VkExportSemaphoreCreateInfo</a>::<code>handleTypes</code> when <code>semaphore</code>’s current payload was created."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportSemaphoreCreateInfo\">VkExportSemaphoreCreateInfo</a>::<code>handleTypes</code> when <code>semaphore</code>’s current payload was created"
},
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133",
- "text": " <code>semaphore</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalSemaphoreProperties\">VkExternalSemaphoreProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>."
+ "text": " <code>semaphore</code> <strong class=\"purple\">must</strong> not currently have its payload replaced by an imported payload as described below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a> unless that imported payload’s handle type was included in <a href=\"#VkExternalSemaphoreProperties\">VkExternalSemaphoreProperties</a>::<code>exportFromImportedHandleTypes</code> for <code>handleType</code>"
},
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01134",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, as defined below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a>, there <strong class=\"purple\">must</strong> be no queue waiting on <code>semaphore</code>."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, as defined below in <a href=\"#synchronization-semaphores-importing\">Importing Semaphore Payloads</a>, there <strong class=\"purple\">must</strong> be no queue waiting on <code>semaphore</code>"
},
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01135",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-semaphores-signaling\">semaphore signal operation</a> pending execution."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> be signaled, or have an associated <a href=\"#synchronization-semaphores-signaling\">semaphore signal operation</a> pending execution"
},
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01136",
"(VK_KHR_external_semaphore_fd)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-03253",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> have been created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_BINARY</code>."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> have been created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_BINARY</code>"
},
{
"vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-03254",
- "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> have an associated semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution."
+ "text": " If <code>handleType</code> refers to a handle type with copy payload transference semantics, <code>semaphore</code> <strong class=\"purple\">must</strong> have an associated semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution"
}
]
},
},
{
"vuid": "VUID-VkSemaphoreSignalInfo-value-03260",
- "text": " <code>value</code> <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on <code>semaphore</code> by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>."
+ "text": " <code>value</code> <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on <code>semaphore</code> by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>"
},
{
"vuid": "VUID-VkSemaphoreSignalInfo-sType-sType",
"(VK_KHR_external_semaphore_win32)": [
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-semaphore-handletypes-win32\">Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR</a> table."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-semaphore-handletypes-win32\">Handle Types Supported by <code>VkImportSemaphoreWin32HandleInfoKHR</code></a> table"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466",
- "text": " If <code>handleType</code> is not <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>."
+ "text": " If <code>handleType</code> is not <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467",
- "text": " If <code>handleType</code> is not <code>0</code> and <code>handle</code> is <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> name a valid synchronization primitive of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code> and <code>handle</code> is <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> name a valid synchronization primitive of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468",
- "text": " If <code>handleType</code> is not <code>0</code> and <code>name</code> is <code>NULL</code>, <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code> and <code>name</code> is <code>NULL</code>, <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469",
- "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>."
+ "text": " If <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542",
- "text": " If <code>handle</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-semaphore-handle-types-compatibility\">external semaphore handle types compatibility</a>."
+ "text": " If <code>handle</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-semaphore-handle-types-compatibility\">external semaphore handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543",
- "text": " If <code>name</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-semaphore-handle-types-compatibility\">external semaphore handle types compatibility</a>."
+ "text": " If <code>name</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-semaphore-handle-types-compatibility\">external semaphore handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03261",
"(VK_KHR_external_semaphore_win32)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03262",
- "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>handle</code> or <code>name</code> was exported."
+ "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT</code> or <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>handle</code> or <code>name</code> was exported"
},
{
"vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-03322",
- "text": " If <code>flags</code> contains <code>VK_SEMAPHORE_IMPORT_TEMPORARY_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field of the semaphore from which <code>handle</code> or <code>name</code> was exported <strong class=\"purple\">must</strong> not be <code>VK_SEMAPHORE_TYPE_TIMELINE</code>."
+ "text": " If <code>flags</code> contains <code>VK_SEMAPHORE_IMPORT_TEMPORARY_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field of the semaphore from which <code>handle</code> or <code>name</code> was exported <strong class=\"purple\">must</strong> not be <code>VK_SEMAPHORE_TYPE_TIMELINE</code>"
}
]
},
"(VK_KHR_external_semaphore_fd)": [
{
"vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-01143",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-semaphore-handletypes-fd\">Handle Types Supported by VkImportSemaphoreFdInfoKHR</a> table."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be a value included in the <a href=\"#synchronization-semaphore-handletypes-fd\">Handle Types Supported by <code>VkImportSemaphoreFdInfoKHR</code></a> table"
},
{
"vuid": "VUID-VkImportSemaphoreFdInfoKHR-fd-01544",
- "text": " <code>fd</code> <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-semaphore-handle-types-compatibility\">external semaphore handle types compatibility</a>."
+ "text": " <code>fd</code> <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-semaphore-handle-types-compatibility\">external semaphore handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-03263",
"(VK_KHR_external_semaphore_fd)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [
{
"vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-03264",
- "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>fd</code> was exported."
+ "text": " If <code>handleType</code> is <code>VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field <strong class=\"purple\">must</strong> match that of the semaphore from which <code>fd</code> was exported"
},
{
"vuid": "VUID-VkImportSemaphoreFdInfoKHR-flags-03323",
- "text": " If <code>flags</code> contains <code>VK_SEMAPHORE_IMPORT_TEMPORARY_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field of the semaphore from which <code>fd</code> was exported <strong class=\"purple\">must</strong> not be <code>VK_SEMAPHORE_TYPE_TIMELINE</code>."
+ "text": " If <code>flags</code> contains <code>VK_SEMAPHORE_IMPORT_TEMPORARY_BIT</code>, the <a href=\"#VkSemaphoreTypeCreateInfo\">VkSemaphoreTypeCreateInfo</a>::<code>semaphoreType</code> field of the semaphore from which <code>fd</code> was exported <strong class=\"purple\">must</strong> not be <code>VK_SEMAPHORE_TYPE_TIMELINE</code>"
}
]
},
"(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-vkCmdSetEvent-commandBuffer-01152",
- "text": " <code>commandBuffer</code>’s current device mask <strong class=\"purple\">must</strong> include exactly one physical device."
+ "text": " <code>commandBuffer</code>’s current device mask <strong class=\"purple\">must</strong> include exactly one physical device"
}
],
"(VK_NV_mesh_shader)": [
"(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-vkCmdResetEvent-commandBuffer-01157",
- "text": " <code>commandBuffer</code>’s current device mask <strong class=\"purple\">must</strong> include exactly one physical device."
+ "text": " <code>commandBuffer</code>’s current device mask <strong class=\"purple\">must</strong> include exactly one physical device"
}
],
"(VK_NV_mesh_shader)": [
},
{
"vuid": "VUID-vkCmdWaitEvents-srcStageMask-01164",
- "text": " Any pipeline stage included in <code>srcStageMask</code> or <code>dstStageMask</code> <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>."
+ "text": " Any pipeline stage included in <code>srcStageMask</code> or <code>dstStageMask</code> <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
"vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-01165",
- "text": " Each element of <code>pMemoryBarriers</code>, <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> not have any access flag included in its <code>srcAccessMask</code> member if that bit is not supported by any of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>."
+ "text": " Each element of <code>pMemoryBarriers</code>, <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> not have any access flag included in its <code>srcAccessMask</code> member if that bit is not supported by any of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
},
{
"vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-01166",
- "text": " Each element of <code>pMemoryBarriers</code>, <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> not have any access flag included in its <code>dstAccessMask</code> member if that bit is not supported by any of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>."
+ "text": " Each element of <code>pMemoryBarriers</code>, <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> not have any access flag included in its <code>dstAccessMask</code> member if that bit is not supported by any of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
},
{
"vuid": "VUID-vkCmdWaitEvents-srcQueueFamilyIndex-02803",
"(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-vkCmdWaitEvents-commandBuffer-01167",
- "text": " <code>commandBuffer</code>’s current device mask <strong class=\"purple\">must</strong> include exactly one physical device."
+ "text": " <code>commandBuffer</code>’s current device mask <strong class=\"purple\">must</strong> include exactly one physical device"
}
],
"(VK_NV_mesh_shader)": [
},
{
"vuid": "VUID-vkCmdPipelineBarrier-pDependencies-02285",
- "text": " If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, the render pass <strong class=\"purple\">must</strong> have been created with at least one <code>VkSubpassDependency</code> instance in <code>VkRenderPassCreateInfo</code>::<code>pDependencies</code> that expresses a dependency from the current subpass to itself, and for which <code>srcStageMask</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>srcStageMask</code>, <code>dstStageMask</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>dstStageMask</code>, <code>dependencyFlags</code> is equal to <code>VkSubpassDependency</code>::<code>dependencyFlags</code>, <code>srcAccessMask</code> member of each element of <code>pMemoryBarriers</code> and <code>pImageMemoryBarriers</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>srcAccessMask</code>, and <code>dstAccessMask</code> member of each element of <code>pMemoryBarriers</code> and <code>pImageMemoryBarriers</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>dstAccessMask</code>"
+ "text": " If <code>vkCmdPipelineBarrier</code> is called within a render pass instance, the render pass <strong class=\"purple\">must</strong> have been created with at least one <code>VkSubpassDependency</code> instance in <a href=\"#VkRenderPassCreateInfo\">VkRenderPassCreateInfo</a>::<code>pDependencies</code> that expresses a dependency from the current subpass to itself, and for which <code>srcStageMask</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>srcStageMask</code>, <code>dstStageMask</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>dstStageMask</code>, <code>dependencyFlags</code> is equal to <code>VkSubpassDependency</code>::<code>dependencyFlags</code>, <code>srcAccessMask</code> member of each element of <code>pMemoryBarriers</code> and <code>pImageMemoryBarriers</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>srcAccessMask</code>, and <code>dstAccessMask</code> member of each element of <code>pMemoryBarriers</code> and <code>pImageMemoryBarriers</code> contains a subset of the bit values in <code>VkSubpassDependency</code>::<code>dstAccessMask</code>"
},
{
"vuid": "VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178",
},
{
"vuid": "VUID-VkBufferMemoryBarrier-buffer-01763",
- "text": " If <code>buffer</code> was created with a sharing mode of <code>VK_SHARING_MODE_CONCURRENT</code>, and one of <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> is <code>VK_QUEUE_FAMILY_IGNORED</code>, the other <strong class=\"purple\">must</strong> be <code>VK_QUEUE_FAMILY_IGNORED</code> or a special queue family reserved for external memory ownership transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>."
+ "text": " If <code>buffer</code> was created with a sharing mode of <code>VK_SHARING_MODE_CONCURRENT</code>, and one of <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> is <code>VK_QUEUE_FAMILY_IGNORED</code>, the other <strong class=\"purple\">must</strong> be <code>VK_QUEUE_FAMILY_IGNORED</code> or a special queue family reserved for external memory ownership transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>"
},
{
"vuid": "VUID-VkBufferMemoryBarrier-buffer-01193",
},
{
"vuid": "VUID-VkBufferMemoryBarrier-buffer-01764",
- "text": " If <code>buffer</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>srcQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>."
+ "text": " If <code>buffer</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>srcQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>"
},
{
"vuid": "VUID-VkBufferMemoryBarrier-buffer-01765",
- "text": " If <code>buffer</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>dstQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>."
+ "text": " If <code>buffer</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>dstQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>"
}
]
},
},
{
"vuid": "VUID-VkImageMemoryBarrier-image-01200",
- "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code>, <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> <strong class=\"purple\">must</strong> either both be <code>VK_QUEUE_FAMILY_IGNORED</code>, or both be a valid queue family (see <a href=\"#devsandqueues-queueprops\">Queue Family Properties</a>)."
+ "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code>, <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> <strong class=\"purple\">must</strong> either both be <code>VK_QUEUE_FAMILY_IGNORED</code>, or both be a valid queue family (see <a href=\"#devsandqueues-queueprops\">Queue Family Properties</a>)"
}
],
"(VK_VERSION_1_1,VK_KHR_external_memory)": [
},
{
"vuid": "VUID-VkImageMemoryBarrier-image-01766",
- "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_CONCURRENT</code>, and one of <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> is <code>VK_QUEUE_FAMILY_IGNORED</code>, the other <strong class=\"purple\">must</strong> be <code>VK_QUEUE_FAMILY_IGNORED</code> or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>."
+ "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_CONCURRENT</code>, and one of <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> is <code>VK_QUEUE_FAMILY_IGNORED</code>, the other <strong class=\"purple\">must</strong> be <code>VK_QUEUE_FAMILY_IGNORED</code> or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>"
},
{
"vuid": "VUID-VkImageMemoryBarrier-image-01201",
- "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>srcQueueFamilyIndex</code> is <code>VK_QUEUE_FAMILY_IGNORED</code>, <code>dstQueueFamilyIndex</code> <strong class=\"purple\">must</strong> also be <code>VK_QUEUE_FAMILY_IGNORED</code>."
+ "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>srcQueueFamilyIndex</code> is <code>VK_QUEUE_FAMILY_IGNORED</code>, <code>dstQueueFamilyIndex</code> <strong class=\"purple\">must</strong> also be <code>VK_QUEUE_FAMILY_IGNORED</code>"
},
{
"vuid": "VUID-VkImageMemoryBarrier-image-01767",
- "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>srcQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>."
+ "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>srcQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>"
},
{
"vuid": "VUID-VkImageMemoryBarrier-image-01768",
- "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>dstQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>."
+ "text": " If <code>image</code> was created with a sharing mode of <code>VK_SHARING_MODE_EXCLUSIVE</code> and <code>dstQueueFamilyIndex</code> is not <code>VK_QUEUE_FAMILY_IGNORED</code>, it <strong class=\"purple\">must</strong> be a valid queue family or a special queue family reserved for external memory transfers, as described in <a href=\"#synchronization-queue-transfers\">Queue Family Ownership Transfer</a>"
}
],
"(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [
},
{
"vuid": "VUID-VkRenderPassCreateInfo-pAttachments-00836",
- "text": " For any member of <code>pAttachments</code> with a <code>loadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>."
+ "text": " For any member of <code>pAttachments</code> with a <code>loadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>"
},
{
"vuid": "VUID-VkRenderPassCreateInfo-pAttachments-02511",
"(VK_VERSION_1_1,VK_KHR_maintenance2)": [
{
"vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01566",
- "text": " For any member of <code>pAttachments</code> with a <code>loadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL</code>."
+ "text": " For any member of <code>pAttachments</code> with a <code>loadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL</code>"
},
{
"vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01567",
- "text": " For any member of <code>pAttachments</code> with a <code>stencilLoadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code>."
+ "text": " For any member of <code>pAttachments</code> with a <code>stencilLoadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code>"
},
{
"vuid": "VUID-VkRenderPassCreateInfo-pNext-01926",
},
{
"vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02550",
- "text": " If <code>fragmentDensityMapAttachment</code> is not <code>VK_ATTACHMENT_UNUSED</code>, <code>fragmentDensityMapAttachment</code> <strong class=\"purple\">must</strong> reference an attachment with a <code>loadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_LOAD</code> or <code>VK_ATTACHMENT_LOAD_OP_DONT_CARE</code>."
+ "text": " If <code>fragmentDensityMapAttachment</code> is not <code>VK_ATTACHMENT_UNUSED</code>, <code>fragmentDensityMapAttachment</code> <strong class=\"purple\">must</strong> reference an attachment with a <code>loadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_LOAD</code> or <code>VK_ATTACHMENT_LOAD_OP_DONT_CARE</code>"
},
{
"vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02551",
- "text": " If <code>fragmentDensityMapAttachment</code> is not <code>VK_ATTACHMENT_UNUSED</code>, <code>fragmentDensityMapAttachment</code> <strong class=\"purple\">must</strong> reference an attachment with a <code>storeOp</code> equal to <code>VK_ATTACHMENT_STORE_OP_DONT_CARE</code>."
+ "text": " If <code>fragmentDensityMapAttachment</code> is not <code>VK_ATTACHMENT_UNUSED</code>, <code>fragmentDensityMapAttachment</code> <strong class=\"purple\">must</strong> reference an attachment with a <code>storeOp</code> equal to <code>VK_ATTACHMENT_STORE_OP_DONT_CARE</code>"
},
{
"vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-sType-sType",
"(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-02250",
- "text": " <code>aspectMask</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> for any index <code>i</code>."
+ "text": " <code>aspectMask</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> for any index <code>i</code>"
}
]
},
},
{
"vuid": "VUID-VkSubpassDescription-pInputAttachments-02647",
- "text": " All attachments in <code>pInputAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have formats whose features contain at least one of <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>."
+ "text": " All attachments in <code>pInputAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have formats whose features contain at least one of <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkSubpassDescription-pColorAttachments-02648",
"(VK_NVX_multiview_per_view_attributes)": [
{
"vuid": "VUID-VkSubpassDescription-flags-00856",
- "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX</code>, it <strong class=\"purple\">must</strong> also include <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX</code>."
+ "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX</code>, it <strong class=\"purple\">must</strong> also include <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX</code>"
}
],
"(VK_QCOM_render_pass_transform)": [
{
"vuid": "VUID-VkSubpassDescription-pInputAttachments-02868",
- "text": " If the render pass is created with <code>VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM</code> each of the elements of <code>pInputAttachments</code> <strong class=\"purple\">must</strong> be <code>VK_ATTACHMENT_UNUSED</code>."
+ "text": " If the render pass is created with <code>VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM</code> each of the elements of <code>pInputAttachments</code> <strong class=\"purple\">must</strong> be <code>VK_ATTACHMENT_UNUSED</code>"
}
]
},
},
{
"vuid": "VUID-VkRenderPassCreateInfo2-pAttachments-02523",
- "text": " For any member of <code>pAttachments</code> with a <code>stencilLoadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL</code>, <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>, or <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code>."
+ "text": " For any member of <code>pAttachments</code> with a <code>stencilLoadOp</code> equal to <code>VK_ATTACHMENT_LOAD_OP_CLEAR</code>, the first use of that attachment <strong class=\"purple\">must</strong> not specify a <code>layout</code> equal to <code>VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL</code>, <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code>, or <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code>"
},
{
"vuid": "VUID-VkRenderPassCreateInfo2-pDependencies-03054",
},
{
"vuid": "VUID-VkSubpassDescription2-pInputAttachments-02897",
- "text": " All attachments in <code>pInputAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have formats whose features contain at least one of <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>."
+ "text": " All attachments in <code>pInputAttachments</code> that are not <code>VK_ATTACHMENT_UNUSED</code> <strong class=\"purple\">must</strong> have formats whose features contain at least one of <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkSubpassDescription2-pColorAttachments-02898",
"(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_NVX_multiview_per_view_attributes)": [
{
"vuid": "VUID-VkSubpassDescription2-flags-03076",
- "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX</code>, it <strong class=\"purple\">must</strong> also include <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX</code>."
+ "text": " If <code>flags</code> includes <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX</code>, it <strong class=\"purple\">must</strong> also include <code>VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX</code>"
}
]
},
},
{
"vuid": "VUID-VkFramebufferCreateInfo-width-00885",
- "text": " <code>width</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " <code>width</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-width-00886",
},
{
"vuid": "VUID-VkFramebufferCreateInfo-height-00887",
- "text": " <code>height</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " <code>height</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-height-00888",
},
{
"vuid": "VUID-VkFramebufferCreateInfo-layers-00889",
- "text": " <code>layers</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " <code>layers</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-layers-00890",
"(VK_EXT_fragment_density_map)": [
{
"vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02552",
- "text": " Each element of <code>pAttachments</code> that is used as a fragment density map attachment by <code>renderPass</code> <strong class=\"purple\">must</strong> not have been created with a <code>flags</code> value including <code>VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT</code>."
+ "text": " Each element of <code>pAttachments</code> that is used as a fragment density map attachment by <code>renderPass</code> <strong class=\"purple\">must</strong> not have been created with a <code>flags</code> value including <code>VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT</code>"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-renderPass-02553",
- "text": " If <code>renderPass</code> has a fragment density map attachment and <a href=\"#features-nonsubsampledimages\">non-subsample image feature</a> is not enabled, each element of <code>pAttachments</code> <strong class=\"purple\">must</strong> have been created with a <code>flags</code> value including <code>VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT</code> unless that element is the fragment density map attachment."
+ "text": " If <code>renderPass</code> has a fragment density map attachment and <a href=\"#features-nonsubsampledimages\">non-subsample image feature</a> is not enabled, each element of <code>pAttachments</code> <strong class=\"purple\">must</strong> have been created with a <code>flags</code> value including <code>VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT</code> unless that element is the fragment density map attachment"
},
{
"vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02554",
},
{
"vuid": "VUID-VkRenderPassBeginInfo-renderPass-00904",
- "text": " <code>renderPass</code> <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkFramebufferCreateInfo</code> structure specified when creating <code>framebuffer</code>"
+ "text": " <code>renderPass</code> <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a> structure specified when creating <code>framebuffer</code>"
},
{
"vuid": "VUID-VkRenderPassBeginInfo-sType-sType",
"(VK_QCOM_render_pass_transform)": [
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02869",
- "text": " If the <code>pNext</code> chain includes <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a>, <code>renderArea</code>::<code>offset</code> <strong class=\"purple\">must</strong> equal (0,0)."
+ "text": " If the <code>pNext</code> chain includes <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a>, <code>renderArea</code>::<code>offset</code> <strong class=\"purple\">must</strong> equal (0,0)"
},
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02870",
- "text": " If the <code>pNext</code> chain includes <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a>, <code>renderArea</code>::<code>extent</code> transformed by <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a>::<code>transform</code> <strong class=\"purple\">must</strong> equal the <code>framebuffer</code> dimensions."
+ "text": " If the <code>pNext</code> chain includes <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a>, <code>renderArea</code>::<code>extent</code> transformed by <a href=\"#VkRenderPassTransformBeginInfoQCOM\">VkRenderPassTransformBeginInfoQCOM</a>::<code>transform</code> <strong class=\"purple\">must</strong> equal the <code>framebuffer</code> dimensions"
}
]
},
"(VK_QCOM_render_pass_transform)": [
{
"vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-transform-02871",
- "text": " <code>transform</code> <strong class=\"purple\">must</strong> be VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, or VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR."
+ "text": " <code>transform</code> <strong class=\"purple\">must</strong> be <code>VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR</code>, <code>VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR</code>, <code>VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR</code>, or <code>VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR</code>"
},
{
"vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-flags-02872",
- "text": " The renderpass must have been created with <a href=\"#VkRenderPassCreateInfo\">VkRenderPassCreateInfo</a>::<code>flags</code> containing VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM."
+ "text": " The <code>renderpass</code> must have been created with <a href=\"#VkRenderPassCreateInfo\">VkRenderPassCreateInfo</a>::<code>flags</code> containing <code>VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM</code>"
},
{
"vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-sType-sType",
},
{
"vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908",
- "text": " <code>deviceRenderAreaCount</code> <strong class=\"purple\">must</strong> either be zero or equal to the number of physical devices in the logical device."
+ "text": " <code>deviceRenderAreaCount</code> <strong class=\"purple\">must</strong> either be zero or equal to the number of physical devices in the logical device"
},
{
"vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType",
},
{
"vuid": "VUID-VkShaderModuleCreateInfo-pCode-01091",
- "text": " If <code>pCode</code> declares any of the capabilities listed as <strong class=\"purple\">optional</strong> in the <a href=\"#spirvenv-capabilities-table\">SPIR-V Environment</a> appendix, the corresponding feature(s) <strong class=\"purple\">must</strong> be enabled."
+ "text": " If <code>pCode</code> declares any of the capabilities listed as <strong class=\"purple\">optional</strong> in the <a href=\"#spirvenv-capabilities-table\">SPIR-V Environment</a> appendix, the corresponding feature(s) <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-VkShaderModuleCreateInfo-sType-sType",
"(VK_EXT_pipeline_creation_cache_control)": [
{
"vuid": "VUID-vkCreateComputePipelines-pipelineCache-02873",
- "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>."
+ "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>"
}
]
},
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02093",
- "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_MESH_BIT_NV</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies a maximum output vertex count, <code>OutputVertices</code>, that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxMeshOutputVertices</code>."
+ "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_MESH_BIT_NV</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies a maximum output vertex count, <code>OutputVertices</code>, that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxMeshOutputVertices</code>"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02094",
- "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_MESH_BIT_NV</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies a maximum output primitive count, <code>OutputPrimitivesNV</code>, that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxMeshOutputPrimitives</code>."
+ "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_MESH_BIT_NV</code>, the identified entry point <strong class=\"purple\">must</strong> have an <code>OpExecutionMode</code> instruction that specifies a maximum output primitive count, <code>OutputPrimitivesNV</code>, that is greater than <code>0</code> and less than or equal to <code>VkPhysicalDeviceMeshShaderPropertiesNV</code>::<code>maxMeshOutputPrimitives</code>"
}
],
"(VK_EXT_shader_stencil_export)": [
"(VK_EXT_subgroup_size_control)": [
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02784",
- "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled."
+ "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02785",
- "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set, the <a href=\"#features-computeFullSubgroups\"><code>computeFullSubgroups</code></a> feature <strong class=\"purple\">must</strong> be enabled."
+ "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set, the <a href=\"#features-computeFullSubgroups\"><code>computeFullSubgroups</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02754",
- "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, <code>flags</code> <strong class=\"purple\">must</strong> not have the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set."
+ "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, <code>flags</code> <strong class=\"purple\">must</strong> not have the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02755",
- "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled, and <code>stage</code> <strong class=\"purple\">must</strong> be a valid bit specified in <a href=\"#limits-required-subgroup-size-stages\"><code>requiredSubgroupSizeStages</code></a>."
+ "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled, and <code>stage</code> <strong class=\"purple\">must</strong> be a valid bit specified in <a href=\"#limits-required-subgroup-size-stages\"><code>requiredSubgroupSizeStages</code></a>"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02756",
- "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain and <code>stage</code> is <code>VK_SHADER_STAGE_COMPUTE_BIT</code>, the local workgroup size of the shader <strong class=\"purple\">must</strong> be less than or equal to the product of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code> and <a href=\"#limits-max-subgroups-per-workgroup\"><code>maxComputeWorkgroupSubgroups</code></a>."
+ "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain and <code>stage</code> is <code>VK_SHADER_STAGE_COMPUTE_BIT</code>, the local workgroup size of the shader <strong class=\"purple\">must</strong> be less than or equal to the product of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code> and <a href=\"#limits-max-subgroups-per-workgroup\"><code>maxComputeWorkgroupSubgroups</code></a>"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02757",
- "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, and <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code>."
+ "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, and <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code>"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02758",
- "text": " If <code>flags</code> has both the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> and <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flags set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-max-subgroup-size\"><code>maxSubgroupSize</code></a>."
+ "text": " If <code>flags</code> has both the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> and <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flags set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-max-subgroup-size\"><code>maxSubgroupSize</code></a>"
},
{
"vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02759",
- "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set and <code>flags</code> does not have the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set and no <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-subgroup-size\"><code>subgroupSize</code></a>."
+ "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set and <code>flags</code> does not have the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set and no <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is included in the <code>pNext</code> chain, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-subgroup-size\"><code>subgroupSize</code></a>"
}
]
},
"(VK_EXT_subgroup_size_control)": [
{
"vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02760",
- "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be a power-of-two integer."
+ "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be a power-of-two integer"
},
{
"vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761",
- "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be greater or equal to <a href=\"#limits-min-subgroup-size\">minSubgroupSize</a>."
+ "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be greater or equal to <a href=\"#limits-min-subgroup-size\">minSubgroupSize</a>"
},
{
"vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762",
- "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-max-subgroup-size\">maxSubgroupSize</a>."
+ "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-max-subgroup-size\">maxSubgroupSize</a>"
},
{
"vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType",
"(VK_EXT_pipeline_creation_cache_control)": [
{
"vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-02876",
- "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>."
+ "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>"
}
]
},
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00731",
- "text": " If <code>pStages</code> includes a tessellation control shader stage and a tessellation evaluation shader stage, <code>pTessellationState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineTessellationStateCreateInfo</code> structure"
+ "text": " If <code>pStages</code> includes a tessellation control shader stage and a tessellation evaluation shader stage, <code>pTessellationState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineTessellationStateCreateInfo\">VkPipelineTessellationStateCreateInfo</a> structure"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00732",
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-blendEnable-02023",
- "text": " If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the <code>blendEnable</code> member of the corresponding element of the <code>pAttachment</code> member of <code>pColorBlendState</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code> if the attached image’s <a href=\"#resources-image-format-features\">format features</a> does not contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT</code>."
+ "text": " If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the <code>blendEnable</code> member of the corresponding element of the <code>pAttachment</code> member of <code>pColorBlendState</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code> if the attached image’s <a href=\"#resources-image-format-features\">format features</a> does not contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT</code>"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-attachmentCount-00746",
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750",
- "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pViewportState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineViewportStateCreateInfo</code> structure"
+ "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pViewportState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineViewportStateCreateInfo\">VkPipelineViewportStateCreateInfo</a> structure"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751",
- "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pMultisampleState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineMultisampleStateCreateInfo</code> structure"
+ "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pMultisampleState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineMultisampleStateCreateInfo\">VkPipelineMultisampleStateCreateInfo</a> structure"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752",
- "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, and <code>subpass</code> uses a depth/stencil attachment, <code>pDepthStencilState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineDepthStencilStateCreateInfo</code> structure"
+ "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, and <code>subpass</code> uses a depth/stencil attachment, <code>pDepthStencilState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> structure"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753",
- "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, and <code>subpass</code> uses color attachments, <code>pColorBlendState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineColorBlendStateCreateInfo</code> structure"
+ "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, and <code>subpass</code> uses color attachments, <code>pColorBlendState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> structure"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754",
"(VK_NV_mesh_shader)": [
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02095",
- "text": " The geometric shader stages provided in <code>pStages</code> <strong class=\"purple\">must</strong> be either from the mesh shading pipeline (<code>stage</code> is <code>VK_SHADER_STAGE_TASK_BIT_NV</code> or <code>VK_SHADER_STAGE_MESH_BIT_NV</code>) or from the primitive shading pipeline (<code>stage</code> is <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code>, or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>)."
+ "text": " The geometric shader stages provided in <code>pStages</code> <strong class=\"purple\">must</strong> be either from the mesh shading pipeline (<code>stage</code> is <code>VK_SHADER_STAGE_TASK_BIT_NV</code> or <code>VK_SHADER_STAGE_MESH_BIT_NV</code>) or from the primitive shading pipeline (<code>stage</code> is <code>VK_SHADER_STAGE_VERTEX_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT</code>, <code>VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT</code>, or <code>VK_SHADER_STAGE_GEOMETRY_BIT</code>)"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-02096",
- "text": " The <code>stage</code> member of one element of <code>pStages</code> <strong class=\"purple\">must</strong> be either <code>VK_SHADER_STAGE_VERTEX_BIT</code> or <code>VK_SHADER_STAGE_MESH_BIT_NV</code>."
+ "text": " The <code>stage</code> member of one element of <code>pStages</code> <strong class=\"purple\">must</strong> be either <code>VK_SHADER_STAGE_VERTEX_BIT</code> or <code>VK_SHADER_STAGE_MESH_BIT_NV</code>"
}
],
"!(VK_VERSION_1_1,VK_KHR_maintenance2)": [
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01757",
"text": " If rasterization is not disabled and <code>subpass</code> uses a depth/stencil attachment in <code>renderPass</code> that has a layout of <code>VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL</code> or <code>VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL</code> in the <code>VkAttachmentReference</code> defined by <code>subpass</code>, the <code>failOp</code>, <code>passOp</code> and <code>depthFailOp</code> members of each of the <code>front</code> and <code>back</code> members of <code>pDepthStencilState</code> <strong class=\"purple\">must</strong> be <code>VK_STENCIL_OP_KEEP</code>"
- },
- {
- "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-01565",
- "text": " If <code>pStages</code> includes a fragment shader stage and an input attachment was referenced by the <a href=\"#VkRenderPassInputAttachmentAspectCreateInfo\">VkRenderPassInputAttachmentAspectCreateInfo</a> at <code>renderPass</code> create time, its shader code <strong class=\"purple\">must</strong> not read from any aspect that was not specified in the <code>aspectMask</code> of the corresponding <a href=\"#VkInputAttachmentAspectReference\">VkInputAttachmentAspectReference</a> structure."
}
],
"!(VK_EXT_depth_range_unrestricted)": [
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00760",
- "text": " If the <code>renderPass</code> has multiview enabled and <code>subpass</code> has more than one bit set in the view mask and <code>multiviewTessellationShader</code> is not enabled, then <code>pStages</code> <strong class=\"purple\">must</strong> not include tessellation shaders."
+ "text": " If the <code>renderPass</code> has multiview enabled and <code>subpass</code> has more than one bit set in the view mask and <code>multiviewTessellationShader</code> is not enabled, then <code>pStages</code> <strong class=\"purple\">must</strong> not include tessellation shaders"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00761",
- "text": " If the <code>renderPass</code> has multiview enabled and <code>subpass</code> has more than one bit set in the view mask and <code>multiviewGeometryShader</code> is not enabled, then <code>pStages</code> <strong class=\"purple\">must</strong> not include a geometry shader."
+ "text": " If the <code>renderPass</code> has multiview enabled and <code>subpass</code> has more than one bit set in the view mask and <code>multiviewGeometryShader</code> is not enabled, then <code>pStages</code> <strong class=\"purple\">must</strong> not include a geometry shader"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00762",
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-00763",
- "text": " If the <code>renderPass</code> has multiview enabled, then all shaders <strong class=\"purple\">must</strong> not include variables decorated with the <code>Layer</code> built-in decoration in their interfaces."
+ "text": " If the <code>renderPass</code> has multiview enabled, then all shaders <strong class=\"purple\">must</strong> not include variables decorated with the <code>Layer</code> built-in decoration in their interfaces"
}
],
"(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00764",
- "text": " <code>flags</code> <strong class=\"purple\">must</strong> not contain the <code>VK_PIPELINE_CREATE_DISPATCH_BASE</code> flag."
+ "text": " <code>flags</code> <strong class=\"purple\">must</strong> not contain the <code>VK_PIPELINE_CREATE_DISPATCH_BASE</code> flag"
+ }
+ ],
+ "(VK_VERSION_1_1,VK_KHR_maintenance2,VK_KHR_create_renderpass2)": [
+ {
+ "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-01565",
+ "text": " If <code>pStages</code> includes a fragment shader stage and an input attachment was referenced by an <code>aspectMask</code> at <code>renderPass</code> creation time, its shader code <strong class=\"purple\">must</strong> only read from the aspects that were specified for that input attachment"
}
],
"(VK_NV_clip_space_w_scaling)": [
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02319",
- "text": " If a <code>VkPipelineRasterizationStateStreamCreateInfoEXT</code>::<code>rasterizationStream</code> value other than zero is specified, all variables in the output interface of the entry point being compiled decorated with <code>Position</code>, <code>PointSize</code>, <code>ClipDistance</code>, or <code>CullDistance</code> <strong class=\"purple\">must</strong> all be decorated with identical <code>Stream</code> values that match the <code>rasterizationStream</code>"
+ "text": " If a <a href=\"#VkPipelineRasterizationStateStreamCreateInfoEXT\">VkPipelineRasterizationStateStreamCreateInfoEXT</a>::<code>rasterizationStream</code> value other than zero is specified, all variables in the output interface of the entry point being compiled decorated with <code>Position</code>, <code>PointSize</code>, <code>ClipDistance</code>, or <code>CullDistance</code> <strong class=\"purple\">must</strong> all be decorated with identical <code>Stream</code> values that match the <code>rasterizationStream</code>"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02320",
- "text": " If <code>VkPipelineRasterizationStateStreamCreateInfoEXT</code>::<code>rasterizationStream</code> is zero, or not specified, all variables in the output interface of the entry point being compiled decorated with <code>Position</code>, <code>PointSize</code>, <code>ClipDistance</code>, or <code>CullDistance</code> <strong class=\"purple\">must</strong> all be decorated with a <code>Stream</code> value of zero, or <strong class=\"purple\">must</strong> not specify the <code>Stream</code> decoration"
+ "text": " If <a href=\"#VkPipelineRasterizationStateStreamCreateInfoEXT\">VkPipelineRasterizationStateStreamCreateInfoEXT</a>::<code>rasterizationStream</code> is zero, or not specified, all variables in the output interface of the entry point being compiled decorated with <code>Position</code>, <code>PointSize</code>, <code>ClipDistance</code>, or <code>CullDistance</code> <strong class=\"purple\">must</strong> all be decorated with a <code>Stream</code> value of zero, or <strong class=\"purple\">must</strong> not specify the <code>Stream</code> decoration"
},
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-geometryStreams-02321",
"(VK_EXT_transform_feedback)+(VK_NV_mesh_shader)": [
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-None-02322",
- "text": " If there are any mesh shader stages in the pipeline there <strong class=\"purple\">must</strong> not be any shader stage in the pipeline with a <code>Xfb</code> execution mode."
+ "text": " If there are any mesh shader stages in the pipeline there <strong class=\"purple\">must</strong> not be any shader stage in the pipeline with a <code>Xfb</code> execution mode"
}
],
"(VK_EXT_line_rasterization)": [
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-02877",
- "text": " If <code>flags</code> includes <code>VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV</code>, then the <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " If <code>flags</code> includes <code>VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV</code>, then the <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_EXT_transform_feedback)": [
+ {
+ "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-02966",
+ "text": " If <code>flags</code> includes <code>VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV</code>, then all stages <strong class=\"purple\">must</strong> not specify <code>Xfb</code> execution mode"
}
],
"(VK_EXT_pipeline_creation_cache_control)": [
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-groupCount-02879",
- "text": " <code>groupCount</code> <strong class=\"purple\">must</strong> be at least <code>1</code> and as maximum <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxGraphicsShaderGroupCount</code>."
+ "text": " <code>groupCount</code> <strong class=\"purple\">must</strong> be at least <code>1</code> and as maximum <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxGraphicsShaderGroupCount</code>"
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-groupCount-02880",
- "text": " The sum of <code>groupCount</code> including those groups added from referenced <code>pPipelines</code> <strong class=\"purple\">must</strong> also be as maximum <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxGraphicsShaderGroupCount</code>."
+ "text": " The sum of <code>groupCount</code> including those groups added from referenced <code>pPipelines</code> <strong class=\"purple\">must</strong> also be as maximum <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxGraphicsShaderGroupCount</code>"
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02881",
- "text": " The state of the first element of <code>pGroups</code> must match its equivalent within the parent’s <code>VkGraphicsPipelineCreateInfo</code>."
+ "text": " The state of the first element of <code>pGroups</code> must match its equivalent within the parent’s <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>"
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02882",
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pPipelines-02886",
- "text": " Each element of the <code>pPipelines</code> member of <code>libraries</code> <strong class=\"purple\">must</strong> have been created with identical state to the pipeline currently created except the state that can be overriden by <code>VkGraphicsShaderGroupCreateInfoNV</code>."
+ "text": " Each element of the <code>pPipelines</code> member of <code>libraries</code> <strong class=\"purple\">must</strong> have been created with identical state to the pipeline currently created except the state that can be overriden by <a href=\"#VkGraphicsShaderGroupCreateInfoNV\">VkGraphicsShaderGroupCreateInfoNV</a>"
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-deviceGeneratedCommands-02887",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-sType-sType",
"(VK_NV_device_generated_commands)+!(VK_NV_mesh_shader)": [
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02883",
- "text": " All elements of <code>pGroups</code> <strong class=\"purple\">must</strong> use the same shader stage combinations."
+ "text": " All elements of <code>pGroups</code> <strong class=\"purple\">must</strong> use the same shader stage combinations"
}
],
"(VK_NV_device_generated_commands)+(VK_NV_mesh_shader)": [
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02884",
- "text": " All elements of <code>pGroups</code> <strong class=\"purple\">must</strong> use the same shader stage combinations unless any mesh shader stage is used, then either combination of task and mesh or just mesh shader is valid."
+ "text": " All elements of <code>pGroups</code> <strong class=\"purple\">must</strong> use the same shader stage combinations unless any mesh shader stage is used, then either combination of task and mesh or just mesh shader is valid"
},
{
"vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02885",
- "text": " Mesh and regular primitive shading stages cannot be mixed across <code>pGroups</code>."
+ "text": " Mesh and regular primitive shading stages cannot be mixed across <code>pGroups</code>"
}
]
},
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-stageCount-02888",
- "text": " For <code>stageCount</code>, the same restrictions as in <code>VkGraphicsPipelineCreateInfo</code>::<code>stageCount</code> apply."
+ "text": " For <code>stageCount</code>, the same restrictions as in <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>stageCount</code> apply"
},
{
"vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-pStages-02889",
- "text": " For <code>pStages</code>, the same restrictions as in <code>VkGraphicsPipelineCreateInfo</code>::<code>pStages</code> apply."
+ "text": " For <code>pStages</code>, the same restrictions as in <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pStages</code> apply"
},
{
"vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-pVertexInputState-02890",
- "text": " For <code>pVertexInputState</code>, the same restrictions as in <code>VkGraphicsPipelineCreateInfo</code>::<code>pVertexInputState</code> apply."
+ "text": " For <code>pVertexInputState</code>, the same restrictions as in <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pVertexInputState</code> apply"
},
{
"vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-pTessellationState-02891",
- "text": " For <code>pTessellationState</code>, the same restrictions as in <code>VkGraphicsPipelineCreateInfo</code>::<code>pTessellationState</code> apply."
+ "text": " For <code>pTessellationState</code>, the same restrictions as in <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a>::<code>pTessellationState</code> apply"
},
{
"vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-sType-sType",
},
{
"vuid": "VUID-vkCmdBindPipeline-pipeline-00781",
- "text": " If the <a href=\"#features-variableMultisampleRate\">variable multisample rate</a> feature is not supported, <code>pipeline</code> is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline <strong class=\"purple\">must</strong> match that set in the previous pipeline"
+ "text": " If the <a href=\"#features-variableMultisampleRate\">variable multisample rate</a> feature is not supported, <code>pipeline</code> is a graphics pipeline, the current subpass <a href=\"#renderpass-noattachments\">uses no attachments</a>, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline <strong class=\"purple\">must</strong> match that set in the previous pipeline"
},
{
"vuid": "VUID-vkCmdBindPipeline-commandBuffer-parameter",
"(VK_KHR_pipeline_library)": [
{
"vuid": "VUID-vkCmdBindPipeline-pipeline-03382",
- "text": " The <code>pipeline</code> <strong class=\"purple\">must</strong> not have been created with <code>VK_PIPELINE_CREATE_LIBRARY_BIT_KHR</code> set."
+ "text": " The <code>pipeline</code> <strong class=\"purple\">must</strong> not have been created with <code>VK_PIPELINE_CREATE_LIBRARY_BIT_KHR</code> set"
}
]
},
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02893",
- "text": " <code>groupIndex</code> must be <code>0</code> or less than the effective <a href=\"#VkGraphicsPipelineShaderGroupsCreateInfoNV\">VkGraphicsPipelineShaderGroupsCreateInfoNV</a>::<code>groupCount</code> including the referenced pipelines."
+ "text": " <code>groupIndex</code> must be <code>0</code> or less than the effective <a href=\"#VkGraphicsPipelineShaderGroupsCreateInfoNV\">VkGraphicsPipelineShaderGroupsCreateInfoNV</a>::<code>groupCount</code> including the referenced pipelines"
},
{
"vuid": "VUID-vkCmdBindPipelineShaderGroupNV-pipelineBindPoint-02894",
},
{
"vuid": "VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02895",
- "text": " The same restrictions as <a href=\"#vkCmdBindPipeline\">vkCmdBindPipeline</a> apply as if the bound pipeline was created only with the Shader Group from the <code>groupIndex</code> information."
+ "text": " The same restrictions as <a href=\"#vkCmdBindPipeline\">vkCmdBindPipeline</a> apply as if the bound pipeline was created only with the Shader Group from the <code>groupIndex</code> information"
},
{
"vuid": "VUID-vkCmdBindPipelineShaderGroupNV-deviceGeneratedCommands-02896",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdBindPipelineShaderGroupNV-commandBuffer-parameter",
"(VK_KHR_pipeline_executable_properties)": [
{
"vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableInfo-03270",
- "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled."
+ "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271",
- "text": " <code>pipeline</code> member of <code>pPipelineInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>."
+ "text": " <code>pipeline</code> member of <code>pPipelineInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>"
},
{
"vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter",
"(VK_KHR_pipeline_executable_properties)": [
{
"vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272",
- "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled."
+ "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273",
- "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>."
+ "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>"
},
{
"vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274",
- "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR</code> set in the <code>flags</code> field of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a> or <a href=\"#VkComputePipelineCreateInfo\">VkComputePipelineCreateInfo</a>."
+ "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR</code> set in the <code>flags</code> field of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a> or <a href=\"#VkComputePipelineCreateInfo\">VkComputePipelineCreateInfo</a>"
},
{
"vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter",
"(VK_KHR_pipeline_executable_properties)": [
{
"vuid": "VUID-VkPipelineExecutableInfoKHR-executableIndex-03275",
- "text": " <code>executableIndex</code> <strong class=\"purple\">must</strong> be less than the number of executables associated with <code>pipeline</code> as returned in the <code>pExecutableCount</code> parameter of <code>vkGetPipelineExecutablePropertiesKHR</code>."
+ "text": " <code>executableIndex</code> <strong class=\"purple\">must</strong> be less than the number of executables associated with <code>pipeline</code> as returned in the <code>pExecutableCount</code> parameter of <code>vkGetPipelineExecutablePropertiesKHR</code>"
},
{
"vuid": "VUID-VkPipelineExecutableInfoKHR-sType-sType",
"(VK_KHR_pipeline_executable_properties)": [
{
"vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableInfo-03276",
- "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled."
+ "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277",
- "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>."
+ "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>"
},
{
"vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278",
- "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR</code> set in the <code>flags</code> field of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a> or <a href=\"#VkComputePipelineCreateInfo\">VkComputePipelineCreateInfo</a>."
+ "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR</code> set in the <code>flags</code> field of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a> or <a href=\"#VkComputePipelineCreateInfo\">VkComputePipelineCreateInfo</a>"
},
{
"vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_NV_ray_tracing)+(VK_EXT_pipeline_creation_cache_control)": [
{
"vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-02903",
- "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>."
+ "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>"
}
]
},
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_EXT_pipeline_creation_cache_control)": [
{
"vuid": "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-02903",
- "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>."
+ "text": " If <code>pipelineCache</code> was created with <code>VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT</code>, host access to <code>pipelineCache</code> <strong class=\"purple\">must</strong> be <a href=\"#fundamentals-threadingbehavior\">externally synchronized</a>"
}
]
},
},
{
"vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02957",
- "text": " <code>flags</code> <strong class=\"purple\">must</strong> not include both <code>VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV</code> and <code>VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT</code> at the same time."
+ "text": " <code>flags</code> <strong class=\"purple\">must</strong> not include both <code>VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV</code> and <code>VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT</code> at the same time"
}
],
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_NV_ray_tracing)+(VK_KHR_pipeline_library)": [
},
{
"vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-libraries-02958",
- "text": " If <code>libraries.pname</code>:libraryCount is zero, then <code>stageCount</code> <strong class=\"purple\">must</strong> not be zero"
+ "text": " If <code>libraries.libraryCount</code> is zero, then <code>stageCount</code> <strong class=\"purple\">must</strong> not be zero"
},
{
"vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-libraries-02959",
- "text": " If <code>libraries.pname</code>:libraryCount is zero, then <code>groupCount</code> <strong class=\"purple\">must</strong> not be zero"
+ "text": " If <code>libraries.libraryCount</code> is zero, then <code>groupCount</code> <strong class=\"purple\">must</strong> not be zero"
},
{
"vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-sType-sType",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-02419",
- "text": " The sum of <code>firstGroup</code> and <code>groupCount</code> <strong class=\"purple\">must</strong> be less than the number of shader groups in <code>pipeline</code>."
+ "text": " The sum of <code>firstGroup</code> and <code>groupCount</code> <strong class=\"purple\">must</strong> be less than the number of shader groups in <code>pipeline</code>"
},
{
"vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-dataSize-02420",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-03483",
- "text": " The sum of <code>firstGroup</code> and <code>groupCount</code> <strong class=\"purple\">must</strong> be less than the number of shader groups in <code>pipeline</code>."
+ "text": " The sum of <code>firstGroup</code> and <code>groupCount</code> <strong class=\"purple\">must</strong> be less than the number of shader groups in <code>pipeline</code>"
},
{
"vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-dataSize-03484",
},
{
"vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-rayTracingShaderGroupHandleCaptureReplay-03485",
- "text": " <code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingShaderGroupHandleCaptureReplay</code> <strong class=\"purple\">must</strong> be enabled to call this function."
+ "text": " <code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingShaderGroupHandleCaptureReplay</code> <strong class=\"purple\">must</strong> be enabled to call this function"
},
{
"vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-device-parameter",
"text": " <code>pipelineStageCreationFeedbackCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
}
],
- "(VK_EXT_pipeline_creation_feedback)+(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
+ "(VK_EXT_pipeline_creation_feedback)+(VK_KHR_ray_tracing)": [
{
"vuid": "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02670",
"text": " When chained to <a href=\"#VkRayTracingPipelineCreateInfoKHR\">VkRayTracingPipelineCreateInfoKHR</a>, <a href=\"#VkPipelineCreationFeedbackEXT\">VkPipelineCreationFeedbackEXT</a>::<code>pipelineStageCreationFeedbackCount</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkRayTracingPipelineCreateInfoKHR\">VkRayTracingPipelineCreateInfoKHR</a>::<code>stageCount</code>"
}
+ ],
+ "(VK_EXT_pipeline_creation_feedback)+(VK_NV_ray_tracing)": [
+ {
+ "vuid": "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02969",
+ "text": " When chained to <a href=\"#VkRayTracingPipelineCreateInfoNV\">VkRayTracingPipelineCreateInfoNV</a>, <a href=\"#VkPipelineCreationFeedbackEXT\">VkPipelineCreationFeedbackEXT</a>::<code>pipelineStageCreationFeedbackCount</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkRayTracingPipelineCreateInfoNV\">VkRayTracingPipelineCreateInfoNV</a>::<code>stageCount</code>"
+ }
]
},
"VkAllocationCallbacks": {
"core": [
{
"vuid": "VUID-vkAllocateMemory-pAllocateInfo-01713",
- "text": " <code>pAllocateInfo->allocationSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryHeaps</code>[memindex].size where <code>memindex</code> = <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryTypes</code>[pAllocateInfo->memoryTypeIndex].heapIndex as returned by <a href=\"#vkGetPhysicalDeviceMemoryProperties\">vkGetPhysicalDeviceMemoryProperties</a> for the <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> that <code>device</code> was created from."
+ "text": " <code>pAllocateInfo->allocationSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryHeaps</code>[memindex].size where <code>memindex</code> = <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryTypes</code>[pAllocateInfo->memoryTypeIndex].heapIndex as returned by <a href=\"#vkGetPhysicalDeviceMemoryProperties\">vkGetPhysicalDeviceMemoryProperties</a> for the <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> that <code>device</code> was created from"
},
{
"vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714",
"(VK_KHR_external_memory)+(VK_NV_external_memory)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-00640",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a> structure, it <strong class=\"purple\">must</strong> not include a <a href=\"#VkExportMemoryAllocateInfoNV\">VkExportMemoryAllocateInfoNV</a> or <a href=\"#VkExportMemoryWin32HandleInfoNV\">VkExportMemoryWin32HandleInfoNV</a> structure."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a> structure, it <strong class=\"purple\">must</strong> not include a <a href=\"#VkExportMemoryAllocateInfoNV\">VkExportMemoryAllocateInfoNV</a> or <a href=\"#VkExportMemoryWin32HandleInfoNV\">VkExportMemoryWin32HandleInfoNV</a> structure"
}
],
"(VK_KHR_external_memory_win32+VK_NV_external_memory_win32)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-00641",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkImportMemoryWin32HandleInfoKHR\">VkImportMemoryWin32HandleInfoKHR</a> structure, it <strong class=\"purple\">must</strong> not include a <a href=\"#VkImportMemoryWin32HandleInfoNV\">VkImportMemoryWin32HandleInfoNV</a> structure."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkImportMemoryWin32HandleInfoKHR\">VkImportMemoryWin32HandleInfoKHR</a> structure, it <strong class=\"purple\">must</strong> not include a <a href=\"#VkImportMemoryWin32HandleInfoNV\">VkImportMemoryWin32HandleInfoNV</a> structure"
}
],
"(VK_KHR_external_memory_fd)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01742",
- "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the memory object being imported was created."
+ "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the memory object being imported was created"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648",
- "text": " If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> be one of those returned by <a href=\"#vkGetMemoryFdPropertiesKHR\">vkGetMemoryFdPropertiesKHR</a>."
+ "text": " If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> be one of those returned by <a href=\"#vkGetMemoryFdPropertiesKHR\">vkGetMemoryFdPropertiesKHR</a>"
}
],
"(VK_KHR_external_memory+VK_KHR_device_group)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-None-00643",
- "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by <a href=\"#VkMemoryAllocateFlagsInfo\">VkMemoryAllocateFlagsInfo</a> <strong class=\"purple\">must</strong> match that specified when the memory object being imported was allocated."
+ "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by <a href=\"#VkMemoryAllocateFlagsInfo\">VkMemoryAllocateFlagsInfo</a> <strong class=\"purple\">must</strong> match that specified when the memory object being imported was allocated"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-None-00644",
- "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to <a href=\"#vkAllocateMemory\">vkAllocateMemory</a> <strong class=\"purple\">must</strong> match the list of physical devices that comprise the logical device on which the memory was originally allocated."
+ "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to <a href=\"#vkAllocateMemory\">vkAllocateMemory</a> <strong class=\"purple\">must</strong> match the list of physical devices that comprise the logical device on which the memory was originally allocated"
}
],
"(VK_KHR_external_memory_win32)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645",
- "text": " If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> be one of those returned by <a href=\"#vkGetMemoryWin32HandlePropertiesKHR\">vkGetMemoryWin32HandlePropertiesKHR</a>."
+ "text": " If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> be one of those returned by <a href=\"#vkGetMemoryWin32HandlePropertiesKHR\">vkGetMemoryWin32HandlePropertiesKHR</a>"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01743",
- "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR</code> or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the memory object being imported was created."
+ "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR</code> or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR</code>, then the values of <code>allocationSize</code> and <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> match those specified when the memory object being imported was created"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00646",
- "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, <code>allocationSize</code> <strong class=\"purple\">must</strong> match the size reported in the memory requirements of the <code>image</code> or <code>buffer</code> member of the <code>VkDedicatedAllocationMemoryAllocateInfoNV</code> structure included in the <code>pNext</code> chain."
+ "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, <code>allocationSize</code> <strong class=\"purple\">must</strong> match the size reported in the memory requirements of the <code>image</code> or <code>buffer</code> member of the <code>VkDedicatedAllocationMemoryAllocateInfoNV</code> structure included in the <code>pNext</code> chain"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00647",
- "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, <code>allocationSize</code> <strong class=\"purple\">must</strong> match the size specified when creating the Direct3D 12 heap from which the external handle was extracted."
+ "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, <code>allocationSize</code> <strong class=\"purple\">must</strong> match the size specified when creating the Direct3D 12 heap from which the external handle was extracted"
}
],
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872",
- "text": " If the protected memory feature is not enabled, the <code>VkMemoryAllocateInfo</code>::<code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> not indicate a memory type that reports <code>VK_MEMORY_PROPERTY_PROTECTED_BIT</code>."
+ "text": " If the protected memory feature is not enabled, the <code>VkMemoryAllocateInfo</code>::<code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> not indicate a memory type that reports <code>VK_MEMORY_PROPERTY_PROTECTED_BIT</code>"
}
],
"(VK_EXT_external_memory_host)": [
"(VK_EXT_external_memory_host)+(VK_NV_dedicated_allocation)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02805",
- "text": " If the parameters define an import operation and the external handle is a host pointer, the <code>pNext</code> chain <strong class=\"purple\">must</strong> not include a <a href=\"#VkDedicatedAllocationMemoryAllocateInfoNV\">VkDedicatedAllocationMemoryAllocateInfoNV</a> structure with either its <code>image</code> or <code>buffer</code> field set to a value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>."
+ "text": " If the parameters define an import operation and the external handle is a host pointer, the <code>pNext</code> chain <strong class=\"purple\">must</strong> not include a <a href=\"#VkDedicatedAllocationMemoryAllocateInfoNV\">VkDedicatedAllocationMemoryAllocateInfoNV</a> structure with either its <code>image</code> or <code>buffer</code> field set to a value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
}
],
"(VK_EXT_external_memory_host)+(VK_KHR_dedicated_allocation)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02806",
- "text": " If the parameters define an import operation and the external handle is a host pointer, the <code>pNext</code> chain <strong class=\"purple\">must</strong> not include a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with either its <code>image</code> or <code>buffer</code> field set to a value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>."
+ "text": " If the parameters define an import operation and the external handle is a host pointer, the <code>pNext</code> chain <strong class=\"purple\">must</strong> not include a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with either its <code>image</code> or <code>buffer</code> field set to a value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
}
],
"(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkMemoryAllocateInfo-allocationSize-02383",
- "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>allocationSize</code> <strong class=\"purple\">must</strong> be the size returned by <a href=\"#vkGetAndroidHardwareBufferPropertiesANDROID\">vkGetAndroidHardwareBufferPropertiesANDROID</a> for the Android hardware buffer."
+ "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>allocationSize</code> <strong class=\"purple\">must</strong> be the size returned by <a href=\"#vkGetAndroidHardwareBufferPropertiesANDROID\">vkGetAndroidHardwareBufferPropertiesANDROID</a> for the Android hardware buffer"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02384",
- "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, and the <code>pNext</code> chain does not include a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure or <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the Android hardware buffer <strong class=\"purple\">must</strong> have a <code>AHardwareBuffer_Desc</code>::<code>format</code> of <code>AHARDWAREBUFFER_FORMAT_BLOB</code> and a <code>AHardwareBuffer_Desc</code>::<code>usage</code> that includes <code>AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER</code>."
+ "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, and the <code>pNext</code> chain does not include a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure or <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> is <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the Android hardware buffer <strong class=\"purple\">must</strong> have a <code>AHardwareBuffer_Desc</code>::<code>format</code> of <code>AHARDWAREBUFFER_FORMAT_BLOB</code> and a <code>AHardwareBuffer_Desc</code>::<code>usage</code> that includes <code>AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER</code>"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-02385",
- "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> be one of those returned by <a href=\"#vkGetAndroidHardwareBufferPropertiesANDROID\">vkGetAndroidHardwareBufferPropertiesANDROID</a> for the Android hardware buffer."
+ "text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> be one of those returned by <a href=\"#vkGetAndroidHardwareBufferPropertiesANDROID\">vkGetAndroidHardwareBufferPropertiesANDROID</a> for the Android hardware buffer"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-01874",
- "text": " If the parameters do not define an import operation, and the <code>pNext</code> chain includes a <code>VkExportMemoryAllocateInfo</code> structure with <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> included in its <code>handleTypes</code> member, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> not equal to <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>allocationSize</code> <strong class=\"purple\">must</strong> be <code>0</code>, otherwise <code>allocationSize</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " If the parameters do not define an import operation, and the <code>pNext</code> chain includes a <code>VkExportMemoryAllocateInfo</code> structure with <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> included in its <code>handleTypes</code> member, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> not equal to <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>allocationSize</code> <strong class=\"purple\">must</strong> be <code>0</code>, otherwise <code>allocationSize</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02386",
- "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the Android hardware buffer’s <a href=\"#AHardwareBuffer\">AHardwareBuffer</a>::<code>usage</code> <strong class=\"purple\">must</strong> include at least one of <code>AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT</code> or <code>AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE</code>."
+ "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the Android hardware buffer’s <a href=\"#AHardwareBuffer\">AHardwareBuffer</a>::<code>usage</code> <strong class=\"purple\">must</strong> include at least one of <code>AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT</code> or <code>AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE</code>"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02387",
- "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the format of <code>image</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code> or the format returned by <a href=\"#vkGetAndroidHardwareBufferPropertiesANDROID\">vkGetAndroidHardwareBufferPropertiesANDROID</a> in <a href=\"#VkAndroidHardwareBufferFormatPropertiesANDROID\">VkAndroidHardwareBufferFormatPropertiesANDROID</a>::<code>format</code> for the Android hardware buffer."
+ "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the format of <code>image</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code> or the format returned by <a href=\"#vkGetAndroidHardwareBufferPropertiesANDROID\">vkGetAndroidHardwareBufferPropertiesANDROID</a> in <a href=\"#VkAndroidHardwareBufferFormatPropertiesANDROID\">VkAndroidHardwareBufferFormatPropertiesANDROID</a>::<code>format</code> for the Android hardware buffer"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02388",
- "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the width, height, and array layer dimensions of <code>image</code> and the Android hardware buffer’s <code>AHardwareBuffer_Desc</code> <strong class=\"purple\">must</strong> be identical."
+ "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the width, height, and array layer dimensions of <code>image</code> and the Android hardware buffer’s <code>AHardwareBuffer_Desc</code> <strong class=\"purple\">must</strong> be identical"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02389",
- "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the Android hardware buffer’s <a href=\"#AHardwareBuffer\">AHardwareBuffer</a>::<code>usage</code> includes <code>AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE</code>, the <code>image</code> <strong class=\"purple\">must</strong> have a complete mipmap chain."
+ "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the Android hardware buffer’s <a href=\"#AHardwareBuffer\">AHardwareBuffer</a>::<code>usage</code> includes <code>AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE</code>, the <code>image</code> <strong class=\"purple\">must</strong> have a complete mipmap chain"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02586",
- "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the Android hardware buffer’s <a href=\"#AHardwareBuffer\">AHardwareBuffer</a>::<code>usage</code> does not include <code>AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE</code>, the <code>image</code> <strong class=\"purple\">must</strong> have exactly one mipmap level."
+ "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, and the Android hardware buffer’s <a href=\"#AHardwareBuffer\">AHardwareBuffer</a>::<code>usage</code> does not include <code>AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE</code>, the <code>image</code> <strong class=\"purple\">must</strong> have exactly one mipmap level"
},
{
"vuid": "VUID-VkMemoryAllocateInfo-pNext-02390",
- "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, each bit set in the usage of <code>image</code> <strong class=\"purple\">must</strong> be listed in <a href=\"#memory-external-android-hardware-buffer-usage\">AHardwareBuffer Usage Equivalence</a>, and if there is a corresponding <code>AHARDWAREBUFFER_USAGE</code> bit listed that bit <strong class=\"purple\">must</strong> be included in the Android hardware buffer’s <code>AHardwareBuffer_Desc</code>::<code>usage</code>."
+ "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the <code>pNext</code> chain includes a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure with <code>image</code> that is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, each bit set in the usage of <code>image</code> <strong class=\"purple\">must</strong> be listed in <a href=\"#memory-external-android-hardware-buffer-usage\">AHardwareBuffer Usage Equivalence</a>, and if there is a corresponding <code>AHARDWAREBUFFER_USAGE</code> bit listed that bit <strong class=\"purple\">must</strong> be included in the Android hardware buffer’s <code>AHardwareBuffer_Desc</code>::<code>usage</code>"
}
],
"(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [
"text": " At least one of <code>image</code> and <code>buffer</code> <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
},
{
- "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01433",
- "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>VkMemoryAllocateInfo</code>::<code>allocationSize</code> <strong class=\"purple\">must</strong> equal the <code>VkMemoryRequirements</code>::<code>size</code> of the image"
- },
- {
"vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01434",
- "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>image</code> <strong class=\"purple\">must</strong> have been created without <code>VK_IMAGE_CREATE_SPARSE_BINDING_BIT</code> set in <code>VkImageCreateInfo</code>::<code>flags</code>"
- },
- {
- "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01435",
- "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>VkMemoryAllocateInfo</code>::<code>allocationSize</code> <strong class=\"purple\">must</strong> equal the <code>VkMemoryRequirements</code>::<code>size</code> of the buffer"
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>image</code> <strong class=\"purple\">must</strong> have been created without <code>VK_IMAGE_CREATE_SPARSE_BINDING_BIT</code> set in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code>"
},
{
"vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01436",
"text": " Both of <code>buffer</code>, and <code>image</code> that are valid handles of non-ignored parameters <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
}
],
+ "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [
+ {
+ "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01433",
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>VkMemoryAllocateInfo</code>::<code>allocationSize</code> <strong class=\"purple\">must</strong> equal the <code>VkMemoryRequirements</code>::<code>size</code> of the image"
+ },
+ {
+ "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01435",
+ "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>VkMemoryAllocateInfo</code>::<code>allocationSize</code> <strong class=\"purple\">must</strong> equal the <code>VkMemoryRequirements</code>::<code>size</code> of the buffer"
+ }
+ ],
+ "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
+ {
+ "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-02964",
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and the memory is not an imported Android Hardware Buffer, <code>VkMemoryAllocateInfo</code>::<code>allocationSize</code> <strong class=\"purple\">must</strong> equal the <code>VkMemoryRequirements</code>::<code>size</code> of the image"
+ },
+ {
+ "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-02965",
+ "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and the memory is not an imported Android Hardware Buffer, <code>VkMemoryAllocateInfo</code>::<code>allocationSize</code> <strong class=\"purple\">must</strong> equal the <code>VkMemoryRequirements</code>::<code>size</code> of the buffer"
+ }
+ ],
"(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_win32)": [
{
"vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01876",
- "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, and the external handle was created by the Vulkan API, then the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> must be identical to the image associated with the imported memory."
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, and the external handle was created by the Vulkan API, then the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> must be identical to the image associated with the imported memory"
},
{
"vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01877",
- "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, and the external handle was created by the Vulkan API, then the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> must be identical to the buffer associated with the imported memory."
+ "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, and the external handle was created by the Vulkan API, then the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> must be identical to the buffer associated with the imported memory"
}
],
"(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)": [
{
"vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01878",
- "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> must be identical to the image associated with the imported memory."
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> must be identical to the image associated with the imported memory"
},
{
"vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01879",
- "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> must be identical to the buffer associated with the imported memory."
+ "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation with handle type <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT</code>, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> must be identical to the buffer associated with the imported memory"
}
],
"(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_sampler_ycbcr_conversion)": [
},
{
"vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650",
- "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the image <strong class=\"purple\">must</strong> have been created with <code>VkDedicatedAllocationImageCreateInfoNV</code>::<code>dedicatedAllocation</code> equal to <code>VK_TRUE</code>"
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the image <strong class=\"purple\">must</strong> have been created with <a href=\"#VkDedicatedAllocationImageCreateInfoNV\">VkDedicatedAllocationImageCreateInfoNV</a>::<code>dedicatedAllocation</code> equal to <code>VK_TRUE</code>"
},
{
"vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651",
- "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the buffer <strong class=\"purple\">must</strong> have been created with <code>VkDedicatedAllocationBufferCreateInfoNV</code>::<code>dedicatedAllocation</code> equal to <code>VK_TRUE</code>"
+ "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, the buffer <strong class=\"purple\">must</strong> have been created with <a href=\"#VkDedicatedAllocationBufferCreateInfoNV\">VkDedicatedAllocationBufferCreateInfoNV</a>::<code>dedicatedAllocation</code> equal to <code>VK_TRUE</code>"
},
{
"vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652",
"(VK_NV_dedicated_allocation)+(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)": [
{
"vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654",
- "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> <strong class=\"purple\">must</strong> be identical to the image associated with the imported memory."
+ "text": " If <code>image</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated image allocation and <code>image</code> <strong class=\"purple\">must</strong> be identical to the image associated with the imported memory"
},
{
"vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655",
- "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> <strong class=\"purple\">must</strong> be identical to the buffer associated with the imported memory."
+ "text": " If <code>buffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> defines a memory import operation, the memory being imported <strong class=\"purple\">must</strong> also be a dedicated buffer allocation and <code>buffer</code> <strong class=\"purple\">must</strong> be identical to the buffer associated with the imported memory"
}
]
},
"(VK_VERSION_1_1,VK_KHR_external_memory)": [
{
"vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-00656",
- "text": " The bits in <code>handleTypes</code> <strong class=\"purple\">must</strong> be supported and compatible, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>."
+ "text": " The bits in <code>handleTypes</code> <strong class=\"purple\">must</strong> be supported and compatible, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>"
},
{
"vuid": "VUID-VkExportMemoryAllocateInfo-sType-sType",
"(VK_KHR_external_memory_win32)": [
{
"vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657",
- "text": " If <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> does not include <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, a <code>VkExportMemoryWin32HandleInfoKHR</code> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a>."
+ "text": " If <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> does not include <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, a <code>VkExportMemoryWin32HandleInfoKHR</code> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a>"
},
{
"vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_memory_win32)": [
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658",
- "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be supported for import, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>."
+ "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be supported for import, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659",
- "text": " The memory from which <code>handle</code> was exported, or the memory named by <code>name</code> <strong class=\"purple\">must</strong> have been created on the same underlying physical device as <code>device</code>."
+ "text": " The memory from which <code>handle</code> was exported, or the memory named by <code>name</code> <strong class=\"purple\">must</strong> have been created on the same underlying physical device as <code>device</code>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660",
- "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle."
+ "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439",
- "text": " If <code>handleType</code> is not <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>."
+ "text": " If <code>handleType</code> is not <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT</code>, <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT</code>, or <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT</code>, <code>name</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440",
- "text": " If <code>handleType</code> is not <code>0</code> and <code>handle</code> is <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> name a valid memory resource of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code> and <code>handle</code> is <code>NULL</code>, <code>name</code> <strong class=\"purple\">must</strong> name a valid memory resource of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661",
- "text": " If <code>handleType</code> is not <code>0</code> and <code>name</code> is <code>NULL</code>, <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code> and <code>name</code> is <code>NULL</code>, <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441",
- "text": " if <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>."
+ "text": " if <code>handle</code> is not <code>NULL</code>, <code>name</code> must be <code>NULL</code>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518",
- "text": " If <code>handle</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-memory-handle-types-compatibility\">external memory handle types compatibility</a>."
+ "text": " If <code>handle</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-memory-handle-types-compatibility\">external memory handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-name-01519",
- "text": " If <code>name</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-memory-handle-types-compatibility\">external memory handle types compatibility</a>."
+ "text": " If <code>name</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-memory-handle-types-compatibility\">external memory handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_memory_win32)": [
{
"vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created"
},
{
"vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663",
- "text": " If <code>handleType</code> is defined as an NT handle, <a href=\"#vkGetMemoryWin32HandleKHR\">vkGetMemoryWin32HandleKHR</a> <strong class=\"purple\">must</strong> be called no more than once for each valid unique combination of <code>memory</code> and <code>handleType</code>."
+ "text": " If <code>handleType</code> is defined as an NT handle, <a href=\"#vkGetMemoryWin32HandleKHR\">vkGetMemoryWin32HandleKHR</a> <strong class=\"purple\">must</strong> be called no more than once for each valid unique combination of <code>memory</code> and <code>handleType</code>"
},
{
"vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as an NT handle or a global share handle"
},
{
"vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType",
"(VK_KHR_external_memory_win32)": [
{
"vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665",
- "text": " <code>handle</code> <strong class=\"purple\">must</strong> be an external memory handle created outside of the Vulkan API."
+ "text": " <code>handle</code> <strong class=\"purple\">must</strong> be an external memory handle created outside of the Vulkan API"
},
{
"vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not be one of the handle types defined as opaque."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not be one of the handle types defined as opaque"
},
{
"vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter",
"(VK_KHR_external_memory_fd)": [
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00667",
- "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be supported for import, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>."
+ "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be supported for import, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>"
},
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-fd-00668",
- "text": " The memory from which <code>fd</code> was exported <strong class=\"purple\">must</strong> have been created on the same underlying physical device as <code>device</code>."
+ "text": " The memory from which <code>fd</code> was exported <strong class=\"purple\">must</strong> have been created on the same underlying physical device as <code>device</code>"
},
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00669",
- "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle."
+ "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle"
},
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00670",
- "text": " If <code>handleType</code> is not <code>0</code>, <code>fd</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>."
+ "text": " If <code>handleType</code> is not <code>0</code>, <code>fd</code> <strong class=\"purple\">must</strong> be a valid handle of the type specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01746",
- "text": " The memory represented by <code>fd</code> <strong class=\"purple\">must</strong> have been created from a physical device and driver that is compatible with <code>device</code> and <code>handleType</code>, as described in <a href=\"#external-memory-handle-types-compatibility\">External memory handle types compatibility</a>."
+ "text": " The memory represented by <code>fd</code> <strong class=\"purple\">must</strong> have been created from a physical device and driver that is compatible with <code>device</code> and <code>handleType</code>, as described in <a href=\"#external-memory-handle-types-compatibility\">External memory handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01520",
- "text": " <code>fd</code> <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-memory-handle-types-compatibility\">external memory handle types compatibility</a>."
+ "text": " <code>fd</code> <strong class=\"purple\">must</strong> obey any requirements listed for <code>handleType</code> in <a href=\"#external-memory-handle-types-compatibility\">external memory handle types compatibility</a>"
},
{
"vuid": "VUID-VkImportMemoryFdInfoKHR-sType-sType",
"(VK_KHR_external_memory_fd)": [
{
"vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00671",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created"
},
{
"vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00672",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> be defined as a POSIX file descriptor handle"
},
{
"vuid": "VUID-VkMemoryGetFdInfoKHR-sType-sType",
"(VK_KHR_external_memory_fd)": [
{
"vuid": "VUID-vkGetMemoryFdPropertiesKHR-fd-00673",
- "text": " <code>fd</code> <strong class=\"purple\">must</strong> be an external memory handle created outside of the Vulkan API."
+ "text": " <code>fd</code> <strong class=\"purple\">must</strong> be an external memory handle created outside of the Vulkan API"
},
{
"vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-00674",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not be <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR</code>."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not be <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR</code>"
},
{
"vuid": "VUID-vkGetMemoryFdPropertiesKHR-device-parameter",
"(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880",
- "text": " If <code>buffer</code> is not <code>NULL</code>, Android hardware buffers <strong class=\"purple\">must</strong> be supported for import, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>."
+ "text": " If <code>buffer</code> is not <code>NULL</code>, Android hardware buffers <strong class=\"purple\">must</strong> be supported for import, as reported by <a href=\"#VkExternalImageFormatProperties\">VkExternalImageFormatProperties</a> or <a href=\"#VkExternalBufferProperties\">VkExternalBufferProperties</a>"
},
{
"vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881",
- "text": " If <code>buffer</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> be a valid Android hardware buffer object with <code>AHardwareBuffer_Desc</code>::<code>format</code> and <code>AHardwareBuffer_Desc</code>::<code>usage</code> compatible with Vulkan as described in <a href=\"#memory-external-android-hardware-buffer\">Android Hardware Buffers</a>."
+ "text": " If <code>buffer</code> is not <code>NULL</code>, it <strong class=\"purple\">must</strong> be a valid Android hardware buffer object with <code>AHardwareBuffer_Desc</code>::<code>format</code> and <code>AHardwareBuffer_Desc</code>::<code>usage</code> compatible with Vulkan as described in <a href=\"#memory-external-android-hardware-buffer\">Android Hardware Buffers</a>"
},
{
"vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-sType-sType",
"(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882",
- "text": " <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created."
+ "text": " <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created"
},
{
"vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883",
- "text": " If the <code>pNext</code> chain of the <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> used to allocate <code>memory</code> included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with non-<code>NULL</code> <code>image</code> member, then that <code>image</code> <strong class=\"purple\">must</strong> already be bound to <code>memory</code>."
+ "text": " If the <code>pNext</code> chain of the <a href=\"#VkMemoryAllocateInfo\">VkMemoryAllocateInfo</a> used to allocate <code>memory</code> included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> with non-<code>NULL</code> <code>image</code> member, then that <code>image</code> <strong class=\"purple\">must</strong> already be bound to <code>memory</code>"
},
{
"vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-sType-sType",
"(VK_NV_external_memory_win32)": [
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327",
- "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not have more than one bit set."
+ "text": " <code>handleType</code> <strong class=\"purple\">must</strong> not have more than one bit set"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handle-01328",
- "text": " <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle to memory, obtained as specified by <code>handleType</code>."
+ "text": " <code>handle</code> <strong class=\"purple\">must</strong> be a valid handle to memory, obtained as specified by <code>handleType</code>"
},
{
"vuid": "VUID-VkImportMemoryWin32HandleInfoNV-sType-sType",
"(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675",
- "text": " If <code>VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT</code> is set, <code>deviceMask</code> <strong class=\"purple\">must</strong> be a valid device mask."
+ "text": " If <code>VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT</code> is set, <code>deviceMask</code> <strong class=\"purple\">must</strong> be a valid device mask"
},
{
"vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676",
"(VK_KHR_device_group)": [
{
"vuid": "VUID-vkMapMemory-memory-00683",
- "text": " <code>memory</code> <strong class=\"purple\">must</strong> not have been allocated with multiple instances."
+ "text": " <code>memory</code> <strong class=\"purple\">must</strong> not have been allocated with multiple instances"
}
]
},
},
{
"vuid": "VUID-VkMappedMemoryRange-size-01389",
- "text": " If <code>size</code> is equal to <code>VK_WHOLE_SIZE</code>, the end of the current mapping of <code>memory</code> <strong class=\"purple\">must</strong> be a multiple of <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>nonCoherentAtomSize</code> bytes from the beginning of the memory object."
+ "text": " If <code>size</code> is equal to <code>VK_WHOLE_SIZE</code>, the end of the current mapping of <code>memory</code> <strong class=\"purple\">must</strong> be a multiple of <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>nonCoherentAtomSize</code> bytes from the beginning of the memory object"
},
{
"vuid": "VUID-VkMappedMemoryRange-offset-00687",
},
{
"vuid": "VUID-VkMappedMemoryRange-size-01390",
- "text": " If <code>size</code> is not equal to <code>VK_WHOLE_SIZE</code>, <code>size</code> <strong class=\"purple\">must</strong> either be a multiple of <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>nonCoherentAtomSize</code>, or <code>offset</code> plus <code>size</code> <strong class=\"purple\">must</strong> equal the size of <code>memory</code>."
+ "text": " If <code>size</code> is not equal to <code>VK_WHOLE_SIZE</code>, <code>size</code> <strong class=\"purple\">must</strong> either be a multiple of <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>nonCoherentAtomSize</code>, or <code>offset</code> plus <code>size</code> <strong class=\"purple\">must</strong> equal the size of <code>memory</code>"
},
{
"vuid": "VUID-VkMappedMemoryRange-sType-sType",
"core": [
{
"vuid": "VUID-VkImageCreateInfo-imageCreateMaxMipLevels-02251",
- "text": " Each of the following values (as described in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>) <strong class=\"purple\">must</strong> not be undefined <code>imageCreateMaxMipLevels</code>, <code>imageCreateMaxArrayLayers</code>, <code>imageCreateMaxExtent</code>, and <code>imageCreateSampleCounts</code>."
+ "text": " Each of the following values (as described in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>) <strong class=\"purple\">must</strong> not be undefined <code>imageCreateMaxMipLevels</code>, <code>imageCreateMaxArrayLayers</code>, <code>imageCreateMaxExtent</code>, and <code>imageCreateSampleCounts</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-sharingMode-00941",
},
{
"vuid": "VUID-VkImageCreateInfo-extent-00944",
- "text": " <code>extent.width</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " <code>extent.width</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-extent-00945",
- "text": " <code>extent.height</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " <code>extent.height</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-extent-00946",
- "text": " <code>extent.depth</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>."
+ "text": " <code>extent.depth</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-mipLevels-00947",
},
{
"vuid": "VUID-VkImageCreateInfo-extent-02252",
- "text": " <code>extent.width</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxExtent.width</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)."
+ "text": " <code>extent.width</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxExtent.width</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)"
},
{
"vuid": "VUID-VkImageCreateInfo-extent-02253",
- "text": " <code>extent.height</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxExtent.height</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)."
+ "text": " <code>extent.height</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxExtent.height</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)"
},
{
"vuid": "VUID-VkImageCreateInfo-extent-02254",
- "text": " <code>extent.depth</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxExtent.depth</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)."
+ "text": " <code>extent.depth</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxExtent.depth</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)"
},
{
"vuid": "VUID-VkImageCreateInfo-imageType-00954",
},
{
"vuid": "VUID-VkImageCreateInfo-mipLevels-00958",
- "text": " <code>mipLevels</code> <strong class=\"purple\">must</strong> be less than or equal to the number of levels in the complete mipmap chain based on <span class=\"eq\"><code>extent.width</code></span>, <span class=\"eq\"><code>extent.height</code></span>, and <span class=\"eq\"><code>extent.depth</code></span>."
+ "text": " <code>mipLevels</code> <strong class=\"purple\">must</strong> be less than or equal to the number of levels in the complete mipmap chain based on <span class=\"eq\"><code>extent.width</code></span>, <span class=\"eq\"><code>extent.height</code></span>, and <span class=\"eq\"><code>extent.depth</code></span>"
},
{
"vuid": "VUID-VkImageCreateInfo-mipLevels-02255",
- "text": " <code>mipLevels</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxMipLevels</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)."
+ "text": " <code>mipLevels</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxMipLevels</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)"
},
{
"vuid": "VUID-VkImageCreateInfo-arrayLayers-02256",
- "text": " <code>arrayLayers</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxArrayLayers</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)."
+ "text": " <code>arrayLayers</code> <strong class=\"purple\">must</strong> be less than or equal to <code>imageCreateMaxArrayLayers</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)"
},
{
"vuid": "VUID-VkImageCreateInfo-imageType-00961",
- "text": " If <code>imageType</code> is <code>VK_IMAGE_TYPE_3D</code>, <code>arrayLayers</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If <code>imageType</code> is <code>VK_IMAGE_TYPE_3D</code>, <code>arrayLayers</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-samples-02257",
},
{
"vuid": "VUID-VkImageCreateInfo-usage-00966",
- "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT</code>, <code>usage</code> <strong class=\"purple\">must</strong> also contain at least one of <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, or <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>."
+ "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT</code>, <code>usage</code> <strong class=\"purple\">must</strong> also contain at least one of <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, or <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-samples-02258",
- "text": " <code>samples</code> <strong class=\"purple\">must</strong> be a bit value that is set in <code>imageCreateSampleCounts</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)."
+ "text": " <code>samples</code> <strong class=\"purple\">must</strong> be a bit value that is set in <code>imageCreateSampleCounts</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>)"
},
{
"vuid": "VUID-VkImageCreateInfo-usage-00968",
"(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkImageCreateInfo-pNext-01974",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure, and its <code>externalFormat</code> member is non-zero the <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure, and its <code>externalFormat</code> member is non-zero the <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-pNext-01975",
- "text": " If the <code>pNext</code> chain does not include a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure, or does and its <code>externalFormat</code> member is <code>0</code>, the <code>format</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>."
+ "text": " If the <code>pNext</code> chain does not include a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure, or does and its <code>externalFormat</code> member is <code>0</code>, the <code>format</code> <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-pNext-02393",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure whose <code>handleTypes</code> member includes <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure whose <code>handleTypes</code> member includes <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-pNext-02394",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure whose <code>handleTypes</code> member includes <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>mipLevels</code> <strong class=\"purple\">must</strong> either be <code>1</code> or equal to the number of levels in the complete mipmap chain based on <span class=\"eq\"><code>extent.width</code></span>, <span class=\"eq\"><code>extent.height</code></span>, and <span class=\"eq\"><code>extent.depth</code></span>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure whose <code>handleTypes</code> member includes <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>, <code>mipLevels</code> <strong class=\"purple\">must</strong> either be <code>1</code> or equal to the number of levels in the complete mipmap chain based on <span class=\"eq\"><code>extent.width</code></span>, <span class=\"eq\"><code>extent.height</code></span>, and <span class=\"eq\"><code>extent.depth</code></span>"
},
{
"vuid": "VUID-VkImageCreateInfo-pNext-02396",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-pNext-02397",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>usage</code> <strong class=\"purple\">must</strong> not include any usages except <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>usage</code> <strong class=\"purple\">must</strong> not include any usages except <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-pNext-02398",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_OPTIMAL</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalFormatANDROID\">VkExternalFormatANDROID</a> structure whose <code>externalFormat</code> member is not <code>0</code>, <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_OPTIMAL</code>"
}
],
"(VK_EXT_fragment_density_map)": [
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-VkImageCreateInfo-flags-01890",
- "text": " If the protected memory feature is not enabled, <code>flags</code> <strong class=\"purple\">must</strong> not contain <code>VK_IMAGE_CREATE_PROTECTED_BIT</code>."
+ "text": " If the protected memory feature is not enabled, <code>flags</code> <strong class=\"purple\">must</strong> not contain <code>VK_IMAGE_CREATE_PROTECTED_BIT</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-None-01891",
- "text": " If any of the bits <code>VK_IMAGE_CREATE_SPARSE_BINDING_BIT</code>, <code>VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT</code>, or <code>VK_IMAGE_CREATE_SPARSE_ALIASED_BIT</code> are set, <code>VK_IMAGE_CREATE_PROTECTED_BIT</code> <strong class=\"purple\">must</strong> not also be set."
+ "text": " If any of the bits <code>VK_IMAGE_CREATE_SPARSE_BINDING_BIT</code>, <code>VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT</code>, or <code>VK_IMAGE_CREATE_SPARSE_ALIASED_BIT</code> are set, <code>VK_IMAGE_CREATE_PROTECTED_BIT</code> <strong class=\"purple\">must</strong> not also be set"
}
],
"(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_NV_external_memory)": [
{
"vuid": "VUID-VkImageCreateInfo-pNext-00988",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfoNV\">VkExternalMemoryImageCreateInfoNV</a> structure, it <strong class=\"purple\">must</strong> not contain a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkExternalMemoryImageCreateInfoNV\">VkExternalMemoryImageCreateInfoNV</a> structure, it <strong class=\"purple\">must</strong> not contain a <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a> structure"
}
],
"(VK_VERSION_1_1,VK_KHR_external_memory)": [
},
{
"vuid": "VUID-VkImageCreateInfo-flags-02259",
- "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT</code>, then <code>mipLevels</code> <strong class=\"purple\">must</strong> be one, <code>arrayLayers</code> <strong class=\"purple\">must</strong> be one, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>. and <code>imageCreateMaybeLinear</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>) <strong class=\"purple\">must</strong> be <code>false</code>."
+ "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT</code>, then <code>mipLevels</code> <strong class=\"purple\">must</strong> be one, <code>arrayLayers</code> <strong class=\"purple\">must</strong> be one, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>. and <code>imageCreateMaybeLinear</code> (as defined in <a href=\"#resources-image-creation-limits\">Image Creation Limits</a>) <strong class=\"purple\">must</strong> be <code>false</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_maintenance2)": [
{
"vuid": "VUID-VkImageCreateInfo-flags-01572",
- "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code>, then <code>format</code> <strong class=\"purple\">must</strong> be a <a href=\"#appendix-compressedtex-bc\">block-compressed image format</a>, an <a href=\"#appendix-compressedtex-etc2\">ETC compressed image format</a>, or an <a href=\"#appendix-compressedtex-astc\">ASTC compressed image format</a>."
+ "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code>, then <code>format</code> <strong class=\"purple\">must</strong> be a <a href=\"#appendix-compressedtex-bc\">block-compressed image format</a>, an <a href=\"#appendix-compressedtex-etc2\">ETC compressed image format</a>, or an <a href=\"#appendix-compressedtex-astc\">ASTC compressed image format</a>"
},
{
"vuid": "VUID-VkImageCreateInfo-flags-01573",
- "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code>, then <code>flags</code> <strong class=\"purple\">must</strong> also contain <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>."
+ "text": " If <code>flags</code> contains <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code>, then <code>flags</code> <strong class=\"purple\">must</strong> also contain <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_external_memory,VK_NV_external_memory)": [
},
{
"vuid": "VUID-VkImageCreateInfo-tiling-02353",
- "text": " If <code>tiling</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> and <code>flags</code> contains <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a> structure with non-zero <code>viewFormatCount</code>."
+ "text": " If <code>tiling</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> and <code>flags</code> contains <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a> structure with non-zero <code>viewFormatCount</code>"
}
],
"(VK_EXT_sample_locations)": [
"(VK_NV_shading_rate_image)": [
{
"vuid": "VUID-VkImageCreateInfo-imageType-02082",
- "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>."
+ "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>imageType</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TYPE_2D</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-samples-02083",
- "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>samples</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLE_COUNT_1_BIT</code>."
+ "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>samples</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLE_COUNT_1_BIT</code>"
},
{
"vuid": "VUID-VkImageCreateInfo-tiling-02084",
- "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_OPTIMAL</code>."
+ "text": " If <code>usage</code> includes <code>VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV</code>, <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_OPTIMAL</code>"
}
]
},
"(VK_NV_dedicated_allocation)": [
{
"vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994",
- "text": " If <code>dedicatedAllocation</code> is <code>VK_TRUE</code>, <code>VkImageCreateInfo</code>::<code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_CREATE_SPARSE_BINDING_BIT</code>, <code>VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT</code>, or <code>VK_IMAGE_CREATE_SPARSE_ALIASED_BIT</code>"
+ "text": " If <code>dedicatedAllocation</code> is <code>VK_TRUE</code>, <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_CREATE_SPARSE_BINDING_BIT</code>, <code>VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT</code>, or <code>VK_IMAGE_CREATE_SPARSE_ALIASED_BIT</code>"
},
{
"vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-sType-sType",
"(VK_VERSION_1_2,VK_KHR_image_format_list)": [
{
"vuid": "VUID-VkImageFormatListCreateInfo-viewFormatCount-01578",
- "text": " If <code>viewFormatCount</code> is not <code>0</code>, all of the formats in the <code>pViewFormats</code> array <strong class=\"purple\">must</strong> be compatible with the format specified in the <code>format</code> field of <code>VkImageCreateInfo</code>, as described in the <a href=\"#formats-compatibility\">compatibility table</a>."
+ "text": " If <code>viewFormatCount</code> is not <code>0</code>, all of the formats in the <code>pViewFormats</code> array <strong class=\"purple\">must</strong> be compatible with the format specified in the <code>format</code> field of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>, as described in the <a href=\"#formats-compatibility\">compatibility table</a>"
},
{
"vuid": "VUID-VkImageFormatListCreateInfo-flags-01579",
- "text": " If <code>VkImageCreateInfo</code>::<code>flags</code> does not contain <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>, <code>viewFormatCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or <code>1</code>."
+ "text": " If <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> does not contain <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>, <code>viewFormatCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or <code>1</code>"
},
{
"vuid": "VUID-VkImageFormatListCreateInfo-viewFormatCount-01580",
- "text": " If <code>viewFormatCount</code> is not <code>0</code>, <code>VkImageCreateInfo</code>::<code>format</code> <strong class=\"purple\">must</strong> be in <code>pViewFormats</code>."
+ "text": " If <code>viewFormatCount</code> is not <code>0</code>, <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>format</code> <strong class=\"purple\">must</strong> be in <code>pViewFormats</code>"
},
{
"vuid": "VUID-VkImageFormatListCreateInfo-sType-sType",
"(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-02263",
- "text": " Each <em>modifier</em> in <code>pDrmFormatModifiers</code> must be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>."
+ "text": " Each <em>modifier</em> in <code>pDrmFormatModifiers</code> must be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
},
{
"vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-sType-sType",
"(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264",
- "text": " <code>drmFormatModifier</code> must be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>."
+ "text": " <code>drmFormatModifier</code> must be compatible with the parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> and its <code>pNext</code> chain, as determined by querying <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
},
{
"vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265",
- "text": " <code>drmFormatModifierPlaneCount</code> <strong class=\"purple\">must</strong> be equal to the <a href=\"#VkDrmFormatModifierPropertiesEXT\">VkDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifierPlaneCount</code> associated with <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>format</code> and <code>drmFormatModifier</code>, as found by querying <a href=\"#VkDrmFormatModifierPropertiesListEXT\">VkDrmFormatModifierPropertiesListEXT</a>."
+ "text": " <code>drmFormatModifierPlaneCount</code> <strong class=\"purple\">must</strong> be equal to the <a href=\"#VkDrmFormatModifierPropertiesEXT\">VkDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifierPlaneCount</code> associated with <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>format</code> and <code>drmFormatModifier</code>, as found by querying <a href=\"#VkDrmFormatModifierPropertiesListEXT\">VkDrmFormatModifierPropertiesListEXT</a>"
},
{
"vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-size-02267",
},
{
"vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-arrayPitch-02268",
- "text": " For each element of <code>pPlaneLayouts</code>, <code>arrayPitch</code> <strong class=\"purple\">must</strong> be 0 if <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>arrayLayers</code> is 1."
+ "text": " For each element of <code>pPlaneLayouts</code>, <code>arrayPitch</code> <strong class=\"purple\">must</strong> be 0 if <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>arrayLayers</code> is 1"
},
{
"vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-depthPitch-02269",
- "text": " For each element of <code>pPlaneLayouts</code>, <code>depthPitch</code> <strong class=\"purple\">must</strong> be 0 if <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>extent.depth</code> is 1."
+ "text": " For each element of <code>pPlaneLayouts</code>, <code>depthPitch</code> <strong class=\"purple\">must</strong> be 0 if <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>extent.depth</code> is 1"
},
{
"vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-sType-sType",
},
{
"vuid": "VUID-vkGetImageSubresourceLayout-tiling-02271",
- "text": " If the <code>tiling</code> of the <code>image</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>, then the <code>aspectMask</code> member of <code>pSubresource</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> and the index <code>i</code> <strong class=\"purple\">must</strong> be less than the <a href=\"#VkDrmFormatModifierPropertiesEXT\"><code>drmFormatModifierPlaneCount</code></a> associated with the image’s <a href=\"#VkImageCreateInfo\"><code>format</code></a> and <a href=\"#VkImageDrmFormatModifierPropertiesEXT\"><code>drmFormatModifier</code></a>."
+ "text": " If the <code>tiling</code> of the <code>image</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>, then the <code>aspectMask</code> member of <code>pSubresource</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> and the index <code>i</code> <strong class=\"purple\">must</strong> be less than the <a href=\"#VkDrmFormatModifierPropertiesEXT\">VkDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifierPlaneCount</code> associated with the image’s <code>format</code> and <a href=\"#VkImageDrmFormatModifierPropertiesEXT\">VkImageDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifier</code>"
}
],
"core": [
"(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-vkGetImageSubresourceLayout-image-01895",
- "text": " If <code>image</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>image</code> <strong class=\"purple\">must</strong> be bound to memory."
+ "text": " If <code>image</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>image</code> <strong class=\"purple\">must</strong> be bound to memory"
}
]
},
"(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-02272",
- "text": " <code>image</code> <strong class=\"purple\">must</strong> have been created with <a href=\"#VkImageCreateInfo\"><code>tiling</code></a> equal to <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>."
+ "text": " <code>image</code> <strong class=\"purple\">must</strong> have been created with <a href=\"#VkImageCreateInfo\"><code>tiling</code></a> equal to <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>"
},
{
"vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-device-parameter",
},
{
"vuid": "VUID-VkImageViewCreateInfo-None-02273",
- "text": " The <a href=\"#resources-image-view-format-features\">format features</a> of the resultant image view <strong class=\"purple\">must</strong> contain at least one bit."
+ "text": " The <a href=\"#resources-image-view-format-features\">format features</a> of the resultant image view <strong class=\"purple\">must</strong> contain at least one bit"
},
{
"vuid": "VUID-VkImageViewCreateInfo-usage-02274",
- "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>, then the <a href=\"#resources-image-view-format-features\">format features</a> of the resultant image view <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT</code>."
+ "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_SAMPLED_BIT</code>, then the <a href=\"#resources-image-view-format-features\">format features</a> of the resultant image view <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-usage-02275",
- "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT</code>."
+ "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_STORAGE_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-usage-02276",
- "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>."
+ "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-usage-02277",
- "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>."
+ "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-usage-02652",
- "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain at least one of <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>."
+ "text": " If <code>usage</code> contains <code>VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT</code>, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain at least one of <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01478",
},
{
"vuid": "VUID-VkImageViewCreateInfo-image-02724",
- "text": " If <code>image</code> is a 3D image created with <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code> set, and <code>viewType</code> is <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>, <code>subresourceRange.baseArrayLayer</code> <strong class=\"purple\">must</strong> be less than the depth computed from <code>baseMipLevel</code> and <code>extent.depth</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created, according to the formula defined in <a href=\"#resources-image-miplevel-sizing\">Image Miplevel Sizing</a>."
+ "text": " If <code>image</code> is a 3D image created with <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code> set, and <code>viewType</code> is <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>, <code>subresourceRange.baseArrayLayer</code> <strong class=\"purple\">must</strong> be less than the depth computed from <code>baseMipLevel</code> and <code>extent.depth</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created, according to the formula defined in <a href=\"#resources-image-miplevel-sizing\">Image Miplevel Sizing</a>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-subresourceRange-02725",
- "text": " If <code>subresourceRange.layerCount</code> is not <code>VK_REMAINING_ARRAY_LAYERS</code>, <code>image</code> is a 3D image created with <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code> set, and <code>viewType</code> is <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>, <code>subresourceRange.layerCount</code> <strong class=\"purple\">must</strong> be non-zero and <span class=\"eq\"><code>subresourceRange.baseArrayLayer</code> + <code>subresourceRange.layerCount</code></span> <strong class=\"purple\">must</strong> be less than or equal to the depth computed from <code>baseMipLevel</code> and <code>extent.depth</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created, according to the formula defined in <a href=\"#resources-image-miplevel-sizing\">Image Miplevel Sizing</a>."
+ "text": " If <code>subresourceRange.layerCount</code> is not <code>VK_REMAINING_ARRAY_LAYERS</code>, <code>image</code> is a 3D image created with <code>VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT</code> set, and <code>viewType</code> is <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>, <code>subresourceRange.layerCount</code> <strong class=\"purple\">must</strong> be non-zero and <span class=\"eq\"><code>subresourceRange.baseArrayLayer</code> + <code>subresourceRange.layerCount</code></span> <strong class=\"purple\">must</strong> be less than or equal to the depth computed from <code>baseMipLevel</code> and <code>extent.depth</code> specified in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> when <code>image</code> was created, according to the formula defined in <a href=\"#resources-image-miplevel-sizing\">Image Miplevel Sizing</a>"
}
],
"!(VK_EXT_fragment_density_map)+!(VK_NV_shading_rate_image)": [
"(VK_VERSION_1_1,VK_KHR_maintenance2)": [
{
"vuid": "VUID-VkImageViewCreateInfo-image-01583",
- "text": " If <code>image</code> was created with the <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code> flag, <code>format</code> <strong class=\"purple\">must</strong> be compatible with, or <strong class=\"purple\">must</strong> be an uncompressed format that is size-compatible with, the <code>format</code> used to create <code>image</code>."
+ "text": " If <code>image</code> was created with the <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code> flag, <code>format</code> <strong class=\"purple\">must</strong> be compatible with, or <strong class=\"purple\">must</strong> be an uncompressed format that is size-compatible with, the <code>format</code> used to create <code>image</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-image-01584",
- "text": " If <code>image</code> was created with the <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code> flag, the <code>levelCount</code> and <code>layerCount</code> members of <code>subresourceRange</code> <strong class=\"purple\">must</strong> both be <code>1</code>."
+ "text": " If <code>image</code> was created with the <code>VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT</code> flag, the <code>levelCount</code> and <code>layerCount</code> members of <code>subresourceRange</code> <strong class=\"purple\">must</strong> both be <code>1</code>"
}
],
"(VK_VERSION_1_2,VK_KHR_image_format_list)": [
{
"vuid": "VUID-VkImageViewCreateInfo-pNext-01585",
- "text": " If a <code>VkImageFormatListCreateInfo</code> structure was included in the <code>pNext</code> chain of the <code>VkImageCreateInfo</code> structure used when creating <code>image</code> and the <code>viewFormatCount</code> field of <code>VkImageFormatListCreateInfo</code> is not zero then <code>format</code> <strong class=\"purple\">must</strong> be one of the formats in <code>VkImageFormatListCreateInfo</code>::<code>pViewFormats</code>."
+ "text": " If a <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a> structure was included in the <code>pNext</code> chain of the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> structure used when creating <code>image</code> and the <code>viewFormatCount</code> field of <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a> is not zero then <code>format</code> <strong class=\"purple\">must</strong> be one of the formats in <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a>::<code>pViewFormats</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
},
{
"vuid": "VUID-VkImageViewCreateInfo-pNext-01970",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkSamplerYcbcrConversionInfo\">VkSamplerYcbcrConversionInfo</a> structure with a <code>conversion</code> value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, all members of <code>components</code> <strong class=\"purple\">must</strong> have the value <code>VK_COMPONENT_SWIZZLE_IDENTITY</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkSamplerYcbcrConversionInfo\">VkSamplerYcbcrConversionInfo</a> structure with a <code>conversion</code> value other than <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, all members of <code>components</code> <strong class=\"purple\">must</strong> have the value <code>VK_COMPONENT_SWIZZLE_IDENTITY</code>"
}
],
"!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
"(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkImageViewCreateInfo-image-02399",
- "text": " If <code>image</code> has an <a href=\"#memory-external-android-hardware-buffer-external-formats\">external format</a>, <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code>."
+ "text": " If <code>image</code> has an <a href=\"#memory-external-android-hardware-buffer-external-formats\">external format</a>, <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-image-02400",
- "text": " If <code>image</code> has an <a href=\"#memory-external-android-hardware-buffer-external-formats\">external format</a>, the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkSamplerYcbcrConversionInfo\">VkSamplerYcbcrConversionInfo</a> structure with a <code>conversion</code> object created with the same external format as <code>image</code>."
+ "text": " If <code>image</code> has an <a href=\"#memory-external-android-hardware-buffer-external-formats\">external format</a>, the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkSamplerYcbcrConversionInfo\">VkSamplerYcbcrConversionInfo</a> structure with a <code>conversion</code> object created with the same external format as <code>image</code>"
},
{
"vuid": "VUID-VkImageViewCreateInfo-image-02401",
- "text": " If <code>image</code> has an <a href=\"#memory-external-android-hardware-buffer-external-formats\">external format</a>, all members of <code>components</code> <strong class=\"purple\">must</strong> be <code>VK_COMPONENT_SWIZZLE_IDENTITY</code>."
+ "text": " If <code>image</code> has an <a href=\"#memory-external-android-hardware-buffer-external-formats\">external format</a>, all members of <code>components</code> <strong class=\"purple\">must</strong> be <code>VK_COMPONENT_SWIZZLE_IDENTITY</code>"
}
],
"(VK_NV_shading_rate_image)": [
"(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_EXT_separate_stencil_usage)": [
{
"vuid": "VUID-VkImageViewCreateInfo-pNext-02661",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkImageViewUsageCreateInfo\">VkImageViewUsageCreateInfo</a> structure, its <code>usage</code> member <strong class=\"purple\">must</strong> not include any bits that were not set in the <code>usage</code> member of the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> structure used to create <code>image</code>."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkImageViewUsageCreateInfo\">VkImageViewUsageCreateInfo</a> structure, its <code>usage</code> member <strong class=\"purple\">must</strong> not include any bits that were not set in the <code>usage</code> member of the <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a> structure used to create <code>image</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_EXT_separate_stencil_usage)": [
}
]
},
+ "vkGetImageViewAddressNVX": {
+ "(VK_NVX_image_view_handle)": [
+ {
+ "vuid": "VUID-vkGetImageViewAddressNVX-device-parameter",
+ "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDevice\">VkDevice</a> handle"
+ },
+ {
+ "vuid": "VUID-vkGetImageViewAddressNVX-imageView-parameter",
+ "text": " <code>imageView</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageView\">VkImageView</a> handle"
+ },
+ {
+ "vuid": "VUID-vkGetImageViewAddressNVX-pProperties-parameter",
+ "text": " <code>pProperties</code> <strong class=\"purple\">must</strong> be a valid pointer to a <a href=\"#VkImageViewAddressPropertiesNVX\">VkImageViewAddressPropertiesNVX</a> structure"
+ },
+ {
+ "vuid": "VUID-vkGetImageViewAddressNVX-imageView-parent",
+ "text": " <code>imageView</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
+ }
+ ]
+ },
+ "VkImageViewAddressPropertiesNVX": {
+ "(VK_NVX_image_view_handle)": [
+ {
+ "vuid": "VUID-VkImageViewAddressPropertiesNVX-sType-sType",
+ "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX</code>"
+ },
+ {
+ "vuid": "VUID-VkImageViewAddressPropertiesNVX-pNext-pNext",
+ "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+ }
+ ]
+ },
"vkGetBufferMemoryRequirements": {
"core": [
{
"(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01897",
- "text": " If <code>image</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>image</code> <strong class=\"purple\">must</strong> be bound to memory."
+ "text": " If <code>image</code> was created with the <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> external memory handle type, then <code>image</code> <strong class=\"purple\">must</strong> be bound to memory"
}
],
"(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [
"(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
{
"vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02281",
- "text": " If the image’s tiling is <code>VK_IMAGE_TILING_LINEAR</code> or <code>VK_IMAGE_TILING_OPTIMAL</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>format plane</em> for the image. (That is, for a two-plane image <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code>, and for a three-plane image <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code>, <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_2_BIT</code>)."
+ "text": " If the image’s <code>tiling</code> is <code>VK_IMAGE_TILING_LINEAR</code> or <code>VK_IMAGE_TILING_OPTIMAL</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>format plane</em> for the image (that is, for a two-plane image <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code>, and for a three-plane image <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code>, <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_2_BIT</code>)"
},
{
"vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType",
"(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02282",
- "text": " If the image’s tiling is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>memory plane</em> for the image. (That is, <code>aspectMask</code> <strong class=\"purple\">must</strong> specify a plane index that is less than the <a href=\"#VkDrmFormatModifierPropertiesEXT\"><code>drmFormatModifierPlaneCount</code></a> associated with the image’s <a href=\"#VkImageCreateInfo\"><code>format</code></a> and <a href=\"#VkImageDrmFormatModifierPropertiesEXT\"><code>drmFormatModifier</code></a>.)"
+ "text": " If the image’s <code>tiling</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>memory plane</em> for the image (that is, <code>aspectMask</code> <strong class=\"purple\">must</strong> specify a plane index that is less than the <a href=\"#VkDrmFormatModifierPropertiesEXT\">VkDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifierPlaneCount</code> associated with the image’s <code>format</code> and <a href=\"#VkImageDrmFormatModifierPropertiesEXT\">VkImageDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifier</code>)"
}
]
},
},
{
"vuid": "VUID-vkBindBufferMemory-memory-01508",
- "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>buffer</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code>, and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>buffer</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code>, and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero"
}
],
"(VK_VERSION_1_1)": [
},
{
"vuid": "VUID-VkBindBufferMemoryInfo-memory-01900",
- "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>buffer</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>buffer</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>buffer</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero"
}
],
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [
"(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
{
"vuid": "VUID-vkBindImageMemory-image-01608",
- "text": " <code>image</code> <strong class=\"purple\">must</strong> not have been created with the <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> set."
+ "text": " <code>image</code> <strong class=\"purple\">must</strong> not have been created with the <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> set"
}
],
"core": [
"(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_NV_dedicated_allocation_image_aliasing)": [
{
"vuid": "VUID-vkBindImageMemory-memory-02628",
- "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is not enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is not enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero"
},
{
"vuid": "VUID-vkBindImageMemory-memory-02629",
- "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero, and <code>image</code> <strong class=\"purple\">must</strong> be either equal to <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> or an image that was created using the same parameters in <code>VkImageCreateInfo</code>, with the exception that <code>extent</code> and <code>arrayLayers</code> <strong class=\"purple\">may</strong> differ subject to the following restrictions: every dimension in the <code>extent</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created; and the <code>arrayLayers</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created."
+ "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero, and <code>image</code> <strong class=\"purple\">must</strong> be either equal to <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> or an image that was created using the same parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>, with the exception that <code>extent</code> and <code>arrayLayers</code> <strong class=\"purple\">may</strong> differ subject to the following restrictions: every dimension in the <code>extent</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created; and the <code>arrayLayers</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created"
}
],
"(VK_VERSION_1_1)": [
},
{
"vuid": "VUID-VkBindImageMemoryInfo-pNext-01618",
- "text": " If the <code>pNext</code> chain includes a <a href=\"#VkBindImagePlaneMemoryInfo\">VkBindImagePlaneMemoryInfo</a> structure, <code>image</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> bit set."
+ "text": " If the <code>pNext</code> chain includes a <a href=\"#VkBindImagePlaneMemoryInfo\">VkBindImagePlaneMemoryInfo</a> structure, <code>image</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_DISJOINT_BIT</code> bit set"
},
{
"vuid": "VUID-VkBindImageMemoryInfo-pNext-01619",
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VK_NV_dedicated_allocation_image_aliasing)": [
{
"vuid": "VUID-VkBindImageMemoryInfo-memory-01903",
- "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero"
}
],
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_NV_dedicated_allocation_image_aliasing)": [
{
"vuid": "VUID-VkBindImageMemoryInfo-memory-02630",
- "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is not enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is not enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero"
},
{
"vuid": "VUID-VkBindImageMemoryInfo-memory-02631",
- "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero, and <code>image</code> <strong class=\"purple\">must</strong> be either equal to <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> or an image that was created using the same parameters in <code>VkImageCreateInfo</code>, with the exception that <code>extent</code> and <code>arrayLayers</code> <strong class=\"purple\">may</strong> differ subject to the following restrictions: every dimension in the <code>extent</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created; and the <code>arrayLayers</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created."
+ "text": " If the <a href=\"#features-dedicatedAllocationImageAliasing\">dedicated allocation image aliasing</a> feature is enabled, and the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included a <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> structure in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero, and <code>image</code> <strong class=\"purple\">must</strong> be either equal to <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> or an image that was created using the same parameters in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>, with the exception that <code>extent</code> and <code>arrayLayers</code> <strong class=\"purple\">may</strong> differ subject to the following restrictions: every dimension in the <code>extent</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created; and the <code>arrayLayers</code> parameter of the image being bound <strong class=\"purple\">must</strong> be equal to or smaller than the original image for which the allocation was created"
}
],
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [
{
"vuid": "VUID-VkBindImageMemoryInfo-image-01630",
- "text": " If <code>image</code> was created with a valid swapchain handle in <a href=\"#VkImageSwapchainCreateInfoKHR\">VkImageSwapchainCreateInfoKHR</a>::<code>swapchain</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a> structure containing the same swapchain handle."
+ "text": " If <code>image</code> was created with a valid swapchain handle in <a href=\"#VkImageSwapchainCreateInfoKHR\">VkImageSwapchainCreateInfoKHR</a>::<code>swapchain</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a> structure containing the same swapchain handle"
},
{
"vuid": "VUID-VkBindImageMemoryInfo-pNext-01631",
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633",
- "text": " At least one of <code>deviceIndexCount</code> and <code>splitInstanceBindRegionCount</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " At least one of <code>deviceIndexCount</code> and <code>splitInstanceBindRegionCount</code> <strong class=\"purple\">must</strong> be zero"
},
{
"vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634",
},
{
"vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635",
- "text": " All elements of <code>pDeviceIndices</code> <strong class=\"purple\">must</strong> be valid device indices."
+ "text": " All elements of <code>pDeviceIndices</code> <strong class=\"purple\">must</strong> be valid device indices"
},
{
"vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636",
},
{
"vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637",
- "text": " Elements of <code>pSplitInstanceBindRegions</code> that correspond to the same instance of an image <strong class=\"purple\">must</strong> not overlap."
+ "text": " Elements of <code>pSplitInstanceBindRegions</code> that correspond to the same instance of an image <strong class=\"purple\">must</strong> not overlap"
},
{
"vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638",
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
{
"vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-02283",
- "text": " If the image’s tiling is <code>VK_IMAGE_TILING_LINEAR</code> or <code>VK_IMAGE_TILING_OPTIMAL</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>format plane</em> for the image. (That is, <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code> for “<code>_2PLANE</code>” formats and <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code>, <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code>, or <code>VK_IMAGE_ASPECT_PLANE_2_BIT</code> for “<code>_3PLANE</code>” formats.)"
+ "text": " If the image’s <code>tiling</code> is <code>VK_IMAGE_TILING_LINEAR</code> or <code>VK_IMAGE_TILING_OPTIMAL</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>format plane</em> for the image (that is, for a two-plane image <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code>, and for a three-plane image <code>planeAspect</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_ASPECT_PLANE_0_BIT</code>, <code>VK_IMAGE_ASPECT_PLANE_1_BIT</code> or <code>VK_IMAGE_ASPECT_PLANE_2_BIT</code>)"
},
{
"vuid": "VUID-VkBindImagePlaneMemoryInfo-sType-sType",
"(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-02284",
- "text": " If the image’s tiling is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>memory plane</em> for the image. (That is, <code>aspectMask</code> <strong class=\"purple\">must</strong> specify a plane index that is less than the <a href=\"#VkDrmFormatModifierPropertiesEXT\"><code>drmFormatModifierPlaneCount</code></a> associated with the image’s <a href=\"#VkImageCreateInfo\"><code>format</code></a> and <a href=\"#VkImageDrmFormatModifierPropertiesEXT\"><code>drmFormatModifier</code></a>.)"
+ "text": " If the image’s <code>tiling</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>, then <code>planeAspect</code> <strong class=\"purple\">must</strong> be a single valid <em>memory plane</em> for the image (that is, <code>aspectMask</code> <strong class=\"purple\">must</strong> specify a plane index that is less than the <a href=\"#VkDrmFormatModifierPropertiesEXT\">VkDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifierPlaneCount</code> associated with the image’s <code>format</code> and <a href=\"#VkImageDrmFormatModifierPropertiesEXT\">VkImageDrmFormatModifierPropertiesEXT</a>::<code>drmFormatModifier</code>)"
}
]
},
},
{
"vuid": "VUID-VkAccelerationStructureCreateInfoKHR-type-03492",
- "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR</code> then <code>pGeometryInfos->
pname</code>:maxPrimitiveCount <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>::<code>maxInstanceCount</code>"
+ "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR</code> then <code>pGeometryInfos->
maxPrimitiveCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceRayTracingPropertiesKHR\">VkPhysicalDeviceRayTracingPropertiesKHR</a>::<code>maxInstanceCount</code>"
},
{
"vuid": "VUID-VkAccelerationStructureCreateInfoKHR-maxPrimitiveCount-03493",
"(VK_EXT_fragment_density_map)": [
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02574",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>minFilter</code> and <code>magFilter</code> <strong class=\"purple\">must</strong> be equal."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>minFilter</code> and <code>magFilter</code> <strong class=\"purple\">must</strong> be equal"
},
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02575",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>mipmapMode</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLER_MIPMAP_MODE_NEAREST</code>."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>mipmapMode</code> <strong class=\"purple\">must</strong> be <code>VK_SAMPLER_MIPMAP_MODE_NEAREST</code>"
},
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02576",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>minLod</code> and <code>maxLod</code> <strong class=\"purple\">must</strong> be zero."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>minLod</code> and <code>maxLod</code> <strong class=\"purple\">must</strong> be zero"
},
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02577",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>addressModeU</code> and <code>addressModeV</code> <strong class=\"purple\">must</strong> each be either <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code> or <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>addressModeU</code> and <code>addressModeV</code> <strong class=\"purple\">must</strong> each be either <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code> or <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>"
},
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02578",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>anisotropyEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>anisotropyEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
},
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02579",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>compareEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>compareEnable</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
},
{
"vuid": "VUID-VkSamplerCreateInfo-flags-02580",
- "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>unnormalizedCoordinates</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>."
+ "text": " If <code>flags</code> includes <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code>, then <code>unnormalizedCoordinates</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
}
]
},
"(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01904",
- "text": " If an external format conversion is being created, <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code>, otherwise it <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>."
+ "text": " If an external format conversion is being created, <code>format</code> <strong class=\"purple\">must</strong> be <code>VK_FORMAT_UNDEFINED</code>, otherwise it <strong class=\"purple\">must</strong> not be <code>VK_FORMAT_UNDEFINED</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
},
{
"vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748",
- "text": " If <code>ycbcrRange</code> is <code>VK_SAMPLER_YCBCR_RANGE_ITU_NARROW</code> then the R, G and B channels obtained by applying the <code>component</code> swizzle to <code>format</code> <strong class=\"purple\">must</strong> each have a bit-depth greater than or equal to 8."
+ "text": " If <code>ycbcrRange</code> is <code>VK_SAMPLER_YCBCR_RANGE_ITU_NARROW</code> then the R, G and B channels obtained by applying the <code>component</code> swizzle to <code>format</code> <strong class=\"purple\">must</strong> each have a bit-depth greater than or equal to 8"
},
{
"vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656",
},
{
"vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-pSetLayouts-03046",
- "text": " If <a href=\"#VkDescriptorSetAllocateInfo\">VkDescriptorSetAllocateInfo</a>::<code>pSetLayouts</code>[i] has a variable descriptor count binding, then <code>pDescriptorCounts</code>[i] <strong class=\"purple\">must</strong> be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created."
+ "text": " If <a href=\"#VkDescriptorSetAllocateInfo\">VkDescriptorSetAllocateInfo</a>::<code>pSetLayouts</code>[i] has a variable descriptor count binding, then <code>pDescriptorCounts</code>[i] <strong class=\"purple\">must</strong> be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created"
},
{
"vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-sType-sType",
"!(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [
{
"vuid": "VUID-vkUpdateDescriptorSets-dstSet-00314",
- "text": " The <code>dstSet</code> member of each element of <code>pDescriptorWrites</code> or <code>pDescriptorCopies</code> <strong class=\"purple\">must</strong> not be used by any command that was recorded to a command buffer which is in the <a href=\"#commandbuffers-lifecycle\">pending state</a>."
+ "text": " The <code>dstSet</code> member of each element of <code>pDescriptorWrites</code> or <code>pDescriptorCopies</code> <strong class=\"purple\">must</strong> not be used by any command that was recorded to a command buffer which is in the <a href=\"#commandbuffers-lifecycle\">pending state</a>"
}
],
"(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [
{
"vuid": "VUID-vkUpdateDescriptorSets-None-03047",
- "text": " Descriptor bindings updated by this command which were created without the <code>VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT</code> or <code>VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT</code> bits set <strong class=\"purple\">must</strong> not be used by any command that was recorded to a command buffer which is in the <a href=\"#commandbuffers-lifecycle\">pending state</a>."
+ "text": " Descriptor bindings updated by this command which were created without the <code>VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT</code> or <code>VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT</code> bits set <strong class=\"purple\">must</strong> not be used by any command that was recorded to a command buffer which is in the <a href=\"#commandbuffers-lifecycle\">pending state</a>"
}
],
"core": [
},
{
"vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00317",
- "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> have identical <code>descriptorType</code> and <code>stageFlags</code>."
+ "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> have identical <code>descriptorType</code> and <code>stageFlags</code>"
},
{
"vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00318",
- "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> all either use immutable samplers or <strong class=\"purple\">must</strong> all not use immutable samplers."
+ "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> all either use immutable samplers or <strong class=\"purple\">must</strong> all not use immutable samplers"
},
{
"vuid": "VUID-VkWriteDescriptorSet-descriptorType-00319",
"(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [
{
"vuid": "VUID-VkWriteDescriptorSet-descriptorCount-03048",
- "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> have identical <a href=\"#VkDescriptorBindingFlagBits\">VkDescriptorBindingFlagBits</a>."
+ "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> have identical <a href=\"#VkDescriptorBindingFlagBits\">VkDescriptorBindingFlagBits</a>"
}
]
},
"core": [
{
"vuid": "VUID-VkDescriptorImageInfo-imageView-01976",
- "text": " If <code>imageView</code> is created from a depth/stencil image, the <code>aspectMask</code> used to create the <code>imageView</code> <strong class=\"purple\">must</strong> include either <code>VK_IMAGE_ASPECT_DEPTH_BIT</code> or <code>VK_IMAGE_ASPECT_STENCIL_BIT</code> but not both."
+ "text": " If <code>imageView</code> is created from a depth/stencil image, the <code>aspectMask</code> used to create the <code>imageView</code> <strong class=\"purple\">must</strong> include either <code>VK_IMAGE_ASPECT_DEPTH_BIT</code> or <code>VK_IMAGE_ASPECT_STENCIL_BIT</code> but not both"
},
{
"vuid": "VUID-VkDescriptorImageInfo-imageLayout-00344",
"(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [
{
"vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354",
- "text": " <code>dstBinding</code> <strong class=\"purple\">must</strong> be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors."
+ "text": " <code>dstBinding</code> <strong class=\"purple\">must</strong> be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors"
},
{
"vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355",
},
{
"vuid": "VUID-vkCmdBindDescriptorSets-firstSet-00360",
- "text": " The sum of <code>firstSet</code> and <code>descriptorSetCount</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPipelineLayoutCreateInfo</code>::<code>setLayoutCount</code> provided when <code>layout</code> was created"
+ "text": " The sum of <code>firstSet</code> and <code>descriptorSetCount</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPipelineLayoutCreateInfo\">VkPipelineLayoutCreateInfo</a>::<code>setLayoutCount</code> provided when <code>layout</code> was created"
},
{
"vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361",
},
{
"vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00364",
- "text": " <code>set</code> <strong class=\"purple\">must</strong> be less than <code>VkPipelineLayoutCreateInfo</code>::<code>setLayoutCount</code> provided when <code>layout</code> was created"
+ "text": " <code>set</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkPipelineLayoutCreateInfo\">VkPipelineLayoutCreateInfo</a>::<code>setLayoutCount</code> provided when <code>layout</code> was created"
},
{
"vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00365",
},
{
"vuid": "VUID-vkCmdBeginQuery-None-02863",
- "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, this command <strong class=\"purple\">must</strong> not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a <code>vkCmdResetQueryPool</code> command affecting the same query."
+ "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, this command <strong class=\"purple\">must</strong> not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a <code>vkCmdResetQueryPool</code> command affecting the same query"
}
]
},
},
{
"vuid": "VUID-vkCmdBeginQueryIndexedEXT-None-02863",
- "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, this command <strong class=\"purple\">must</strong> not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a <code>vkCmdResetQueryPool</code> command affecting the same query."
+ "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, this command <strong class=\"purple\">must</strong> not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a <code>vkCmdResetQueryPool</code> command affecting the same query"
}
]
},
"(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [
{
"vuid": "VUID-VkPerformanceValueDataINTEL-valueString-parameter",
- "text": " <code>valueString</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid"
+ "text": " <code>valueString</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string"
}
]
},
"(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [
{
"vuid": "VUID-VkPerformanceStreamMarkerInfoINTEL-marker-02735",
- "text": " The value written by the application into <code>marker</code> <strong class=\"purple\">must</strong> only used the valid bits as reported by <a href=\"#vkGetPerformanceParameterINTEL\">vkGetPerformanceParameterINTEL</a> with the <code>VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL</code>."
+ "text": " The value written by the application into <code>marker</code> <strong class=\"purple\">must</strong> only used the valid bits as reported by <a href=\"#vkGetPerformanceParameterINTEL\">vkGetPerformanceParameterINTEL</a> with the <code>VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL</code>"
},
{
"vuid": "VUID-VkPerformanceStreamMarkerInfoINTEL-sType-sType",
"(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [
{
"vuid": "VUID-vkCmdSetPerformanceOverrideINTEL-pOverrideInfo-02736",
- "text": " <code>pOverrideInfo</code> <strong class=\"purple\">must</strong> not be used with a <a href=\"#VkPerformanceOverrideTypeINTEL\">VkPerformanceOverrideTypeINTEL</a> that is not reported available by <code>vkGetPerformanceParameterINTEL</code>."
+ "text": " <code>pOverrideInfo</code> <strong class=\"purple\">must</strong> not be used with a <a href=\"#VkPerformanceOverrideTypeINTEL\">VkPerformanceOverrideTypeINTEL</a> that is not reported available by <code>vkGetPerformanceParameterINTEL</code>"
},
{
"vuid": "VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-parameter",
"(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [
{
"vuid": "VUID-vkReleasePerformanceConfigurationINTEL-configuration-02737",
- "text": " <code>configuration</code> <strong class=\"purple\">must</strong> not be released before all command buffers submitted while the configuration was set are in <a href=\"#commandbuffers-lifecycle\">pending state</a>."
+ "text": " <code>configuration</code> <strong class=\"purple\">must</strong> not be released before all command buffers submitted while the configuration was set are in <a href=\"#commandbuffers-lifecycle\">pending state</a>"
},
{
"vuid": "VUID-vkReleasePerformanceConfigurationINTEL-device-parameter",
"(VK_VERSION_1_1,VK_KHR_maintenance1)": [
{
"vuid": "VUID-vkCmdClearColorImage-image-01993",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>image</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>image</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>"
}
],
"core": [
"(VK_VERSION_1_1,VK_KHR_maintenance1)": [
{
"vuid": "VUID-vkCmdClearDepthStencilImage-image-01994",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>image</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>image</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>"
}
],
"!(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [
"core": [
{
"vuid": "VUID-vkCmdClearAttachments-aspectMask-02501",
- "text": " If the <code>aspectMask</code> member of any element of <code>pAttachments</code> contains <code>VK_IMAGE_ASPECT_COLOR_BIT</code>, then the <code>colorAttachment</code> member of that element <strong class=\"purple\">must</strong> either refer to a color attachment which is <code>VK_ATTACHMENT_UNUSED</code>, or <strong class=\"purple\">must</strong> be a valid color attachment."
+ "text": " If the <code>aspectMask</code> member of any element of <code>pAttachments</code> contains <code>VK_IMAGE_ASPECT_COLOR_BIT</code>, then the <code>colorAttachment</code> member of that element <strong class=\"purple\">must</strong> either refer to a color attachment which is <code>VK_ATTACHMENT_UNUSED</code>, or <strong class=\"purple\">must</strong> be a valid color attachment"
},
{
"vuid": "VUID-vkCmdClearAttachments-aspectMask-02502",
"(VK_VERSION_1_1)": [
{
"vuid": "VUID-vkCmdClearAttachments-commandBuffer-02504",
- "text": " If <code>commandBuffer</code> is an unprotected command buffer, then each attachment to be cleared <strong class=\"purple\">must</strong> not be a protected image."
+ "text": " If <code>commandBuffer</code> is an unprotected command buffer, then each attachment to be cleared <strong class=\"purple\">must</strong> not be a protected image"
},
{
"vuid": "VUID-vkCmdClearAttachments-commandBuffer-02505",
- "text": " If <code>commandBuffer</code> is a protected command buffer, then each attachment to be cleared <strong class=\"purple\">must</strong> not be an unprotected image."
+ "text": " If <code>commandBuffer</code> is a protected command buffer, then each attachment to be cleared <strong class=\"purple\">must</strong> not be an unprotected image"
}
],
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdClearAttachments-baseArrayLayer-00018",
- "text": " If the render pass instance this is recorded in uses multiview, then <code>baseArrayLayer</code> <strong class=\"purple\">must</strong> be zero and <code>layerCount</code> <strong class=\"purple\">must</strong> be one."
+ "text": " If the render pass instance this is recorded in uses multiview, then <code>baseArrayLayer</code> <strong class=\"purple\">must</strong> be zero and <code>layerCount</code> <strong class=\"purple\">must</strong> be one"
}
]
},
"(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkClearAttachment-aspectMask-02246",
- "text": " <code>aspectMask</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> for any index <code>i</code>."
+ "text": " <code>aspectMask</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> for any index <code>i</code>"
}
]
},
"(VK_VERSION_1_1,VK_KHR_maintenance1)": [
{
"vuid": "VUID-vkCmdCopyImage-srcImage-01995",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_SRC_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_SRC_BIT</code>"
},
{
"vuid": "VUID-vkCmdCopyImage-dstImage-01996",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>"
}
],
"!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
},
{
"vuid": "VUID-VkImageCopy-srcImage-01789",
- "text": " If the calling command’s <code>srcImage</code> or <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, then <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> or <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, then <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_maintenance1)": [
},
{
"vuid": "VUID-VkImageCopy-srcImage-01790",
- "text": " If both <code>srcImage</code> and <code>dstImage</code> are of type <code>VK_IMAGE_TYPE_2D</code> then <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If both <code>srcImage</code> and <code>dstImage</code> are of type <code>VK_IMAGE_TYPE_2D</code> then <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageCopy-srcImage-01791",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, and the <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then <code>extent.depth</code> <strong class=\"purple\">must</strong> equal to the <code>layerCount</code> member of <code>srcSubresource</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, and the <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then <code>extent.depth</code> <strong class=\"purple\">must</strong> equal to the <code>layerCount</code> member of <code>srcSubresource</code>"
},
{
"vuid": "VUID-VkImageCopy-dstImage-01792",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, and the <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then <code>extent.depth</code> <strong class=\"purple\">must</strong> equal to the <code>layerCount</code> member of <code>dstSubresource</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, and the <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then <code>extent.depth</code> <strong class=\"purple\">must</strong> equal to the <code>layerCount</code> member of <code>dstSubresource</code>"
}
],
"core": [
},
{
"vuid": "VUID-VkImageCopy-srcImage-00146",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageCopy-srcOffset-00147",
},
{
"vuid": "VUID-VkImageCopy-srcImage-01785",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageCopy-dstImage-01786",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageCopy-srcImage-01787",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, then <code>srcOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_2D</code>, then <code>srcOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code>"
},
{
"vuid": "VUID-VkImageCopy-dstImage-01788",
},
{
"vuid": "VUID-VkImageCopy-dstImage-00152",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageCopy-dstOffset-00153",
"(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkImageSubresourceLayers-aspectMask-02247",
- "text": " <code>aspectMask</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> for any index <code>i</code>."
+ "text": " <code>aspectMask</code> <strong class=\"purple\">must</strong> not include <code>VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT</code> for any index <code>i</code>"
}
]
},
"(VK_VERSION_1_1,VK_KHR_maintenance1)": [
{
"vuid": "VUID-vkCmdCopyBufferToImage-dstImage-01997",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_DST_BIT</code>"
}
],
"!(VK_KHR_shared_presentable_image)": [
"(VK_VERSION_1_1,VK_KHR_maintenance1)": [
{
"vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-01998",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_SRC_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_TRANSFER_SRC_BIT</code>"
}
],
"!(VK_KHR_shared_presentable_image)": [
"!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
{
"vuid": "VUID-VkBufferImageCopy-bufferOffset-00193",
- "text": " If the calling command’s <code>VkImage</code> parameter’s format is not a depth/stencil format, then <code>bufferOffset</code> <strong class=\"purple\">must</strong> be a multiple of the format’s texel block size."
+ "text": " If the calling command’s <code>VkImage</code> parameter’s format is not a depth/stencil format, then <code>bufferOffset</code> <strong class=\"purple\">must</strong> be a multiple of the format’s texel block size"
},
{
"vuid": "VUID-VkBufferImageCopy-bufferRowLength-00203",
"(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [
{
"vuid": "VUID-VkBufferImageCopy-bufferOffset-01558",
- "text": " If the calling command’s <code>VkImage</code> parameter’s format is not a depth/stencil format or a <a href=\"#formats-requiring-sampler-ycbcr-conversion\">multi-planar format</a>, then <code>bufferOffset</code> <strong class=\"purple\">must</strong> be a multiple of the format’s texel block size."
+ "text": " If the calling command’s <code>VkImage</code> parameter’s format is not a depth/stencil format or a <a href=\"#formats-requiring-sampler-ycbcr-conversion\">multi-planar format</a>, then <code>bufferOffset</code> <strong class=\"purple\">must</strong> be a multiple of the format’s texel block size"
},
{
"vuid": "VUID-VkBufferImageCopy-bufferOffset-01559",
},
{
"vuid": "VUID-VkBufferImageCopy-srcImage-00199",
- "text": " If the calling command’s <code>srcImage</code> (<a href=\"#vkCmdCopyImageToBuffer\">vkCmdCopyImageToBuffer</a>) or <code>dstImage</code> (<a href=\"#vkCmdCopyBufferToImage\">vkCmdCopyBufferToImage</a>) is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>imageOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>imageExtent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> (<a href=\"#vkCmdCopyImageToBuffer\">vkCmdCopyImageToBuffer</a>) or <code>dstImage</code> (<a href=\"#vkCmdCopyBufferToImage\">vkCmdCopyBufferToImage</a>) is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>imageOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>imageExtent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkBufferImageCopy-imageOffset-00200",
"(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [
{
"vuid": "VUID-vkCmdBlitImage-filter-02002",
- "text": " If <code>filter</code> is <code>VK_FILTER_CUBIC_EXT</code>, then the <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT</code>."
+ "text": " If <code>filter</code> is <code>VK_FILTER_CUBIC_EXT</code>, then the <a href=\"#resources-image-format-features\">format features</a> of <code>srcImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT</code>"
},
{
"vuid": "VUID-vkCmdBlitImage-filter-00237",
},
{
"vuid": "VUID-VkImageBlit-srcImage-00245",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageBlit-srcOffset-00246",
},
{
"vuid": "VUID-VkImageBlit-srcImage-00247",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>srcOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>srcOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageBlit-dstOffset-00248",
},
{
"vuid": "VUID-VkImageBlit-dstImage-00250",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageBlit-dstOffset-00251",
},
{
"vuid": "VUID-VkImageBlit-dstImage-00252",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>dstOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>dstOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageBlit-srcSubresource-parameter",
},
{
"vuid": "VUID-vkCmdResolveImage-dstImage-02003",
- "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>."
+ "text": " The <a href=\"#resources-image-format-features\">format features</a> of <code>dstImage</code> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
},
{
"vuid": "VUID-vkCmdResolveImage-srcImage-01386",
},
{
"vuid": "VUID-VkImageResolve-srcImage-00271",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>srcOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageResolve-srcOffset-00272",
},
{
"vuid": "VUID-VkImageResolve-srcImage-00273",
- "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>srcOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>srcOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageResolve-dstOffset-00274",
},
{
"vuid": "VUID-VkImageResolve-dstImage-00276",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then <code>dstOffset.y</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.height</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageResolve-dstOffset-00277",
},
{
"vuid": "VUID-VkImageResolve-dstImage-00278",
- "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>dstOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>."
+ "text": " If the calling command’s <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then <code>dstOffset.z</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>extent.depth</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
"vuid": "VUID-VkImageResolve-srcSubresource-parameter",
"(VK_AMD_buffer_marker)": [
{
"vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798",
- "text": " <code>dstOffset</code> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>dstBuffer</code> minus <code>4</code>."
+ "text": " <code>dstOffset</code> <strong class=\"purple\">must</strong> be less than or equal to the size of <code>dstBuffer</code> minus <code>4</code>"
},
{
"vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCmdBindIndexBuffer-indexType-02507",
- "text": " <code>indexType</code> <strong class=\"purple\">must</strong> not be <code>VK_INDEX_TYPE_NONE_KHR</code>."
+ "text": " <code>indexType</code> <strong class=\"purple\">must</strong> not be <code>VK_INDEX_TYPE_NONE_KHR</code>"
}
],
"(VK_EXT_index_type_uint8)": [
},
{
"vuid": "VUID-vkCmdDraw-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDraw-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDraw-None-02686",
"(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDraw-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1)": [
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDraw-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawIndexed-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndexed-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndexed-None-02686",
"(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawIndexed-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1)": [
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawIndirect-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndirect-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndirect-None-02686",
"(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawIndirect-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1)": [
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawIndirectCount-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndirectCount-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndirectCount-None-02686",
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawIndirectCount-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawIndirectCount-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawIndexedIndirect-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndexedIndirect-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndexedIndirect-None-02686",
"(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawIndexedIndirect-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1)": [
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndexedIndirectCount-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02686",
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawIndexedIndirectCount-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawIndexedIndirectCount-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawIndirectByteCountEXT-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndirectByteCountEXT-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02686",
"(VK_EXT_transform_feedback)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawIndirectByteCountEXT-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [
"(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawIndirectByteCountEXT-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_EXT_transform_feedback)+(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-VkConditionalRenderingBeginInfoEXT-offset-01983",
- "text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than the size of <code>buffer</code> by at least 32 bits."
+ "text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than the size of <code>buffer</code> by at least 32 bits"
},
{
"vuid": "VUID-VkConditionalRenderingBeginInfoEXT-offset-01984",
},
{
"vuid": "VUID-vkCmdDrawMeshTasksNV-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawMeshTasksNV-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawMeshTasksNV-None-02686",
"(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawMeshTasksNV-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
"(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawMeshTasksNV-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02686",
"(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
"(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderPass-02684",
- "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-subpass-02685",
- "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>."
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
},
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02686",
"(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [
"(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maxMultiviewInstanceIndex-02688",
- "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>."
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
}
],
"(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [
},
{
"vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870",
- "text": " <code>divisor</code> <strong class=\"purple\">must</strong> be a value between <code>0</code> and <code>VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</code>::<code>maxVertexAttribDivisor</code>, inclusive."
+ "text": " <code>divisor</code> <strong class=\"purple\">must</strong> be a value between <code>0</code> and <code>VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</code>::<code>maxVertexAttribDivisor</code>, inclusive"
},
{
"vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871",
- "text": " <a href=\"#VkVertexInputBindingDescription\">VkVertexInputBindingDescription</a>::<code>inputRate</code> <strong class=\"purple\">must</strong> be of type <code>VK_VERTEX_INPUT_RATE_INSTANCE</code> for this <code>binding</code>."
+ "text": " <a href=\"#VkVertexInputBindingDescription\">VkVertexInputBindingDescription</a>::<code>inputRate</code> <strong class=\"purple\">must</strong> be of type <code>VK_VERTEX_INPUT_RATE_INSTANCE</code> for this <code>binding</code>"
}
]
},
},
{
"vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-shadingRateImageEnable-02056",
- "text": " If <code>shadingRateImageEnable</code> is <code>VK_TRUE</code>, <code>viewportCount</code> <strong class=\"purple\">must</strong> be equal to the <code>viewportCount</code> member of <code>VkPipelineViewportStateCreateInfo</code>"
+ "text": " If <code>shadingRateImageEnable</code> is <code>VK_TRUE</code>, <code>viewportCount</code> <strong class=\"purple\">must</strong> be equal to the <code>viewportCount</code> member of <a href=\"#VkPipelineViewportStateCreateInfo\">VkPipelineViewportStateCreateInfo</a>"
},
{
"vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-pDynamicStates-02057",
"(VK_NV_shading_rate_image)": [
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-None-02058",
- "text": " The <a href=\"#features-shadingRateImage\">shading rate image</a> feature <strong class=\"purple\">must</strong> be enabled."
+ "text": " The <a href=\"#features-shadingRateImage\">shading rate image</a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02059",
- "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageView\">VkImageView</a> handle of type <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>."
+ "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageView\">VkImageView</a> handle of type <code>VK_IMAGE_VIEW_TYPE_2D</code> or <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code>"
},
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02060",
- "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> have a format of <code>VK_FORMAT_R8_UINT</code>."
+ "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, it <strong class=\"purple\">must</strong> have a format of <code>VK_FORMAT_R8_UINT</code>"
},
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02061",
},
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02062",
- "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>imageLayout</code> <strong class=\"purple\">must</strong> match the actual <a href=\"#VkImageLayout\">VkImageLayout</a> of each subresource accessible from <code>imageView</code> at the time the subresource is accessed."
+ "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>imageLayout</code> <strong class=\"purple\">must</strong> match the actual <a href=\"#VkImageLayout\">VkImageLayout</a> of each subresource accessible from <code>imageView</code> at the time the subresource is accessed"
},
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-imageLayout-02063",
- "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>imageLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code>."
+ "text": " If <code>imageView</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>imageLayout</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV</code> or <code>VK_IMAGE_LAYOUT_GENERAL</code>"
},
{
"vuid": "VUID-vkCmdBindShadingRateImageNV-commandBuffer-parameter",
"(VK_NV_shading_rate_image)": [
{
"vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-None-02064",
- "text": " The <a href=\"#features-shadingRateImage\">shading rate image</a> feature <strong class=\"purple\">must</strong> be enabled."
+ "text": " The <a href=\"#features-shadingRateImage\">shading rate image</a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02066",
},
{
"vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-02234",
- "text": " The array <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> not contain two structures with matching values for both the <code>shadingRate</code> and <code>sampleCount</code> members."
+ "text": " The array <code>pCustomSampleOrders</code> <strong class=\"purple\">must</strong> not contain two structures with matching values for both the <code>shadingRate</code> and <code>sampleCount</code> members"
},
{
"vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sType-sType",
"(VK_NV_shading_rate_image)": [
{
"vuid": "VUID-VkCoarseSampleOrderCustomNV-shadingRate-02073",
- "text": " <code>shadingRate</code> <strong class=\"purple\">must</strong> be a shading rate that generates fragments with more than one pixel."
+ "text": " <code>shadingRate</code> <strong class=\"purple\">must</strong> be a shading rate that generates fragments with more than one pixel"
},
{
"vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleCount-02074",
- "text": " <code>sampleCount</code> <strong class=\"purple\">must</strong> correspond to a sample count enumerated in <a href=\"#VkSampleCountFlags\">VkSampleCountFlags</a> whose corresponding bit is set in <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>framebufferNoAttachmentsSampleCounts</code>."
+ "text": " <code>sampleCount</code> <strong class=\"purple\">must</strong> correspond to a sample count enumerated in <a href=\"#VkSampleCountFlags\">VkSampleCountFlags</a> whose corresponding bit is set in <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>framebufferNoAttachmentsSampleCounts</code>"
},
{
"vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02075",
- "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be equal to the product of <code>sampleCount</code>, the fragment width for <code>shadingRate</code>, and the fragment height for <code>shadingRate</code>."
+ "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be equal to the product of <code>sampleCount</code>, the fragment width for <code>shadingRate</code>, and the fragment height for <code>shadingRate</code>"
},
{
"vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02076",
- "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be less than or equal to the value of <code>VkPhysicalDeviceShadingRateImagePropertiesNV</code>::<code>shadingRateMaxCoarseSamples</code>."
+ "text": " <code>sampleLocationCount</code> <strong class=\"purple\">must</strong> be less than or equal to the value of <code>VkPhysicalDeviceShadingRateImagePropertiesNV</code>::<code>shadingRateMaxCoarseSamples</code>"
},
{
"vuid": "VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-02077",
- "text": " The array <code>pSampleLocations</code> <strong class=\"purple\">must</strong> contain exactly one entry for every combination of valid values for <code>pixelX</code>, <code>pixelY</code>, and <code>sample</code> in the structure <a href=\"#VkCoarseSampleOrderCustomNV\">VkCoarseSampleOrderCustomNV</a>."
+ "text": " The array <code>pSampleLocations</code> <strong class=\"purple\">must</strong> contain exactly one entry for every combination of valid values for <code>pixelX</code>, <code>pixelY</code>, and <code>sample</code> in the structure <a href=\"#VkCoarseSampleOrderCustomNV\">VkCoarseSampleOrderCustomNV</a>"
},
{
"vuid": "VUID-VkCoarseSampleOrderCustomNV-shadingRate-parameter",
"(VK_NV_shading_rate_image)": [
{
"vuid": "VUID-VkCoarseSampleLocationNV-pixelX-02078",
- "text": " <code>pixelX</code> <strong class=\"purple\">must</strong> be less than the width (in pixels) of the fragment."
+ "text": " <code>pixelX</code> <strong class=\"purple\">must</strong> be less than the width (in pixels) of the fragment"
},
{
"vuid": "VUID-VkCoarseSampleLocationNV-pixelY-02079",
- "text": " <code>pixelY</code> <strong class=\"purple\">must</strong> be less than the height (in pixels) of the fragment."
+ "text": " <code>pixelY</code> <strong class=\"purple\">must</strong> be less than the height (in pixels) of the fragment"
},
{
"vuid": "VUID-VkCoarseSampleLocationNV-sample-02080",
- "text": " <code>sample</code> <strong class=\"purple\">must</strong> be less than the number of coverage samples in each pixel belonging to the fragment."
+ "text": " <code>sample</code> <strong class=\"purple\">must</strong> be less than the number of coverage samples in each pixel belonging to the fragment"
}
]
},
},
{
"vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029",
- "text": " <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or identical to the <code>viewportCount</code> member of <code>VkPipelineViewportStateCreateInfo</code>"
+ "text": " <code>exclusiveScissorCount</code> <strong class=\"purple\">must</strong> be <code>0</code> or identical to the <code>viewportCount</code> member of <a href=\"#VkPipelineViewportStateCreateInfo\">VkPipelineViewportStateCreateInfo</a>"
},
{
"vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pDynamicStates-02030",
"(VK_NV_scissor_exclusive)": [
{
"vuid": "VUID-vkCmdSetExclusiveScissorNV-None-02031",
- "text": " The <a href=\"#features-exclusiveScissor\">exclusive scissor</a> feature <strong class=\"purple\">must</strong> be enabled."
+ "text": " The <a href=\"#features-exclusiveScissor\">exclusive scissor</a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02033",
},
{
"vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407",
- "text": " If <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>::<code>advancedBlendIndependentBlend</code> is <code>VK_FALSE</code> and <code>colorBlendOp</code> is an <a href=\"#framebuffer-blend-advanced\">advanced blend operation</a>, then <code>colorBlendOp</code> <strong class=\"purple\">must</strong> be the same for all attachments."
+ "text": " If <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>::<code>advancedBlendIndependentBlend</code> is <code>VK_FALSE</code> and <code>colorBlendOp</code> is an <a href=\"#framebuffer-blend-advanced\">advanced blend operation</a>, then <code>colorBlendOp</code> <strong class=\"purple\">must</strong> be the same for all attachments"
},
{
"vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408",
- "text": " If <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>::<code>advancedBlendIndependentBlend</code> is <code>VK_FALSE</code> and <code>alphaBlendOp</code> is an <a href=\"#framebuffer-blend-advanced\">advanced blend operation</a>, then <code>alphaBlendOp</code> <strong class=\"purple\">must</strong> be the same for all attachments."
+ "text": " If <a href=\"#VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\">VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT</a>::<code>advancedBlendIndependentBlend</code> is <code>VK_FALSE</code> and <code>alphaBlendOp</code> is an <a href=\"#framebuffer-blend-advanced\">advanced blend operation</a>, then <code>alphaBlendOp</code> <strong class=\"purple\">must</strong> be the same for all attachments"
},
{
"vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409",
"(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDispatch-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1)": [
"(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDispatchIndirect-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1)": [
},
{
"vuid": "VUID-vkCmdDispatchBase-baseGroupX-00427",
- "text": " If any of <code>baseGroupX</code>, <code>baseGroupY</code>, or <code>baseGroupZ</code> are not zero, then the bound compute pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_PIPELINE_CREATE_DISPATCH_BASE</code> flag."
+ "text": " If any of <code>baseGroupX</code>, <code>baseGroupY</code>, or <code>baseGroupZ</code> are not zero, then the bound compute pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_PIPELINE_CREATE_DISPATCH_BASE</code> flag"
},
{
"vuid": "VUID-vkCmdDispatchBase-commandBuffer-parameter",
"(VK_VERSION_1_1,VK_KHR_device_group)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdDispatchBase-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)": [
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-vkCreateIndirectCommandsLayoutNV-deviceGeneratedCommands-02929",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCreateIndirectCommandsLayoutNV-device-parameter",
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02932",
- "text": " If <code>pTokens</code> contains an entry of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV</code> it <strong class=\"purple\">must</strong> be the first element of the array and there <strong class=\"purple\">must</strong> be only a single element of such token type."
+ "text": " If <code>pTokens</code> contains an entry of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV</code> it <strong class=\"purple\">must</strong> be the first element of the array and there <strong class=\"purple\">must</strong> be only a single element of such token type"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02933",
- "text": " If <code>pTokens</code> contains an entry of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV</code> there <strong class=\"purple\">must</strong> be only a single element of such token type."
+ "text": " If <code>pTokens</code> contains an entry of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV</code> there <strong class=\"purple\">must</strong> be only a single element of such token type"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02934",
- "text": " All state tokens in <code>pTokens</code> <strong class=\"purple\">must</strong> occur prior work provoking tokens (<code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV</code>, <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV</code>, <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV</code>)."
+ "text": " All state tokens in <code>pTokens</code> <strong class=\"purple\">must</strong> occur prior work provoking tokens (<code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV</code>, <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV</code>, <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV</code>)"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02935",
- "text": " The content of <code>pTokens</code> <strong class=\"purple\">must</strong> include one single work provoking token that is compatible with the <code>pipelineBindPoint</code>."
+ "text": " The content of <code>pTokens</code> <strong class=\"purple\">must</strong> include one single work provoking token that is compatible with the <code>pipelineBindPoint</code>"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-streamCount-02936",
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pStreamStrides-02937",
- "text": " each element of <code>pStreamStrides</code> <strong class=\"purple\">must</strong> be greater than `0`and less than or equal to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxIndirectCommandsStreamStride</code>. Furthermore the alignment of each token input <strong class=\"purple\">must</strong> be ensured."
+ "text": " each element of <code>pStreamStrides</code> <strong class=\"purple\">must</strong> be greater than `0`and less than or equal to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxIndirectCommandsStreamStride</code>. Furthermore the alignment of each token input <strong class=\"purple\">must</strong> be ensured"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-sType-sType",
},
{
"vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-deviceGeneratedCommands-02941",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-device-parameter",
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkIndirectCommandsStreamNV-buffer-02942",
- "text": " The <code>buffer</code>’s usage flag <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set."
+ "text": " The <code>buffer</code>’s usage flag <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
},
{
"vuid": "VUID-VkIndirectCommandsStreamNV-offset-02943",
"text": " The <code>offset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minIndirectCommandsBufferOffsetAlignment</code>."
},
{
+ "vuid": "VUID-VkIndirectCommandsStreamNV-buffer-02975",
+ "text": " If <code>buffer</code> is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
+ },
+ {
"vuid": "VUID-VkIndirectCommandsStreamNV-buffer-parameter",
"text": " <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBuffer\">VkBuffer</a> handle"
}
},
{
"vuid": "VUID-VkBindShaderGroupIndirectCommandNV-index-02945",
- "text": " The <code>index</code> <strong class=\"purple\">must</strong> be within range of the accessible shader groups of the current bound graphics pipeline. See <a href=\"#vkCmdBindPipelineShaderGroupNV\">vkCmdBindPipelineShaderGroupNV</a> for further details."
+ "text": " The <code>index</code> <strong class=\"purple\">must</strong> be within range of the accessible shader groups of the current bound graphics pipeline. See <a href=\"#vkCmdBindPipelineShaderGroupNV\">vkCmdBindPipelineShaderGroupNV</a> for further details"
}
]
},
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkBindIndexBufferIndirectCommandNV-None-02946",
- "text": " The buffer’s usage flag from which the address was acquired <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDEX_BUFFER_BIT</code> bit set."
+ "text": " The buffer’s usage flag from which the address was acquired <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDEX_BUFFER_BIT</code> bit set"
},
{
"vuid": "VUID-VkBindIndexBufferIndirectCommandNV-bufferAddress-02947",
- "text": " The <code>bufferAddress</code> <strong class=\"purple\">must</strong> be aligned to the <code>indexType</code> used."
+ "text": " The <code>bufferAddress</code> <strong class=\"purple\">must</strong> be aligned to the <code>indexType</code> used"
},
{
"vuid": "VUID-VkBindIndexBufferIndirectCommandNV-None-02948",
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkBindVertexBufferIndirectCommandNV-None-02949",
- "text": " The buffer’s usage flag from which the address was acquired <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_VERTEX_BUFFER_BIT</code> bit set."
+ "text": " The buffer’s usage flag from which the address was acquired <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_VERTEX_BUFFER_BIT</code> bit set"
},
{
"vuid": "VUID-VkBindVertexBufferIndirectCommandNV-None-02950",
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkIndirectCommandsLayoutTokenNV-stream-02951",
- "text": " <code>stream</code> <strong class=\"purple\">must</strong> be smaller than <code>VkIndirectCommandsLayoutCreateInfoNV</code>::<code>streamCount</code>."
+ "text": " <code>stream</code> <strong class=\"purple\">must</strong> be smaller than <code>VkIndirectCommandsLayoutCreateInfoNV</code>::<code>streamCount</code>"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutTokenNV-offset-02952",
"text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>maxIndirectCommandsTokenOffset</code>."
},
{
- "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-vertexBindingUnit-02953",
- "text": " <code>vertexBindingUnit</code> <strong class=\"purple\">must</strong> stay within device supported limits for the appropriate commands."
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02976",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV</code>, <code>vertexBindingUnit</code> <strong class=\"purple\">must</strong> stay within device supported limits for the appropriate commands"
},
{
- "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-pushconstantOffset-02954",
- "text": " <code>pushconstantOffset</code> <strong class=\"purple\">must</strong> stay within device supported limits for the appropriate commands."
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02977",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, <code>pushconstantPipelineLayout</code> <strong class=\"purple\">must</strong> be valid"
},
{
- "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-pushconstantSize-02955",
- "text": " <code>pushconstantSize</code> <strong class=\"purple\">must</strong> stay within device supported limits for the appropriate commands."
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02978",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, <code>pushconstantOffset</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code>"
},
{
- "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-indirectStateFlags-02956",
- "text": " <code>indirectStateFlags</code> <strong class=\"purple\">must</strong> not be ´0´."
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02979",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, <code>pushconstantSize</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code>"
+ },
+ {
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02980",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, <code>pushconstantOffset</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxPushConstantsSize</code>"
+ },
+ {
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02981",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, <code>pushconstantSize</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxPushConstantsSize</code> minus <code>pushconstantOffset</code>"
+ },
+ {
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02982",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, for each byte in the range specified by <code>pushconstantOffset</code> and <code>pushconstantSize</code> and for each shader stage in <code>pushconstantShaderStageFlags</code>, there <strong class=\"purple\">must</strong> be a push constant range in <code>pushconstantPipelineLayout</code> that includes that byte and that stage"
+ },
+ {
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02983",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, for each byte in the range specified by <code>pushconstantOffset</code> and <code>pushconstantSize</code> and for each push constant range that overlaps that byte, <code>pushconstantShaderStageFlags</code> <strong class=\"purple\">must</strong> include all stages in that push constant range’s <a href=\"#VkPushConstantRange\">VkPushConstantRange</a>::<code>pushconstantShaderStageFlags</code>"
+ },
+ {
+ "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02984",
+ "text": " If <code>tokenType</code> is <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV</code>, <code>indirectStateFlags</code> <strong class=\"purple\">must</strong> not be ´0´"
},
{
"vuid": "VUID-VkIndirectCommandsLayoutTokenNV-sType-sType",
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-vkGetGeneratedCommandsMemoryRequirementsNV-deviceGeneratedCommands-02906",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkGetGeneratedCommandsMemoryRequirementsNV-device-parameter",
{
"vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-pNext-pNext",
"text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-pipelineBindPoint-parameter",
+ "text": " <code>pipelineBindPoint</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPipelineBindPoint\">VkPipelineBindPoint</a> value"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-pipeline-parameter",
+ "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPipeline\">VkPipeline</a> handle"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-indirectCommandsLayout-parameter",
+ "text": " <code>indirectCommandsLayout</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkIndirectCommandsLayoutNV\">VkIndirectCommandsLayoutNV</a> handle"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-commonparent",
+ "text": " Both of <code>indirectCommandsLayout</code>, and <code>pipeline</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
}
]
},
"vkCmdExecuteGeneratedCommandsNV": {
"(VK_NV_device_generated_commands)": [
{
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02690",
+ "text": " If a <code>VkImageView</code> is sampled with <code>VK_FILTER_LINEAR</code> as a result of this command, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT</code>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02691",
+ "text": " If a <code>VkImageView</code> is accessed using atomic operations as a result of this command, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT</code>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02697",
+ "text": " For each set <em>n</em> that is statically used by the <code>VkPipeline</code> bound to the pipeline bind point used by this command, a descriptor set <strong class=\"purple\">must</strong> have been bound to <em>n</em> at the same pipeline bind point, with a <code>VkPipelineLayout</code> that is compatible for set <em>n</em>, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02698",
+ "text": " For each push constant that is statically used by the <code>VkPipeline</code> bound to the pipeline bind point used by this command, a push constant value <strong class=\"purple\">must</strong> have been set for the same pipeline bind point, with a <code>VkPipelineLayout</code> that is compatible for push constants, with the <code>VkPipelineLayout</code> used to create the current <code>VkPipeline</code>, as described in <a href=\"#descriptorsets-compatibility\">Pipeline Layout Compatibility</a>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02699",
+ "text": " Descriptors in each bound descriptor set, specified via <code>vkCmdBindDescriptorSets</code>, <strong class=\"purple\">must</strong> be valid if they are statically used by the <code>VkPipeline</code> bound to the pipeline bind point used by this command"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02700",
+ "text": " A valid pipeline <strong class=\"purple\">must</strong> be bound to the pipeline bind point used by this command"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02701",
+ "text": " If the <code>VkPipeline</code> object bound to the pipeline bind point used by this command requires any dynamic state, that state <strong class=\"purple\">must</strong> have been set for <code>commandBuffer</code>, and done so after any previously bound pipeline with the corresponding state not specified as dynamic"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02859",
+ "text": " There <strong class=\"purple\">must</strong> not have been any calls to dynamic state setting commands for any state not specified as dynamic in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command, since that pipeline was bound"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02702",
+ "text": " If the <code>VkPipeline</code> object bound to the pipeline bind point used by this command accesses a <code>VkSampler</code> object that uses unnormalized coordinates, that sampler <strong class=\"purple\">must</strong> not be used to sample from any <code>VkImage</code> with a <code>VkImageView</code> of the type <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, <code>VK_IMAGE_VIEW_TYPE_1D_ARRAY</code>, <code>VK_IMAGE_VIEW_TYPE_2D_ARRAY</code> or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>, in any shader stage"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02703",
+ "text": " If the <code>VkPipeline</code> object bound to the pipeline bind point used by this command accesses a <code>VkSampler</code> object that uses unnormalized coordinates, that sampler <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions with <code>ImplicitLod</code>, <code>Dref</code> or <code>Proj</code> in their name, in any shader stage"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02704",
+ "text": " If the <code>VkPipeline</code> object bound to the pipeline bind point used by this command accesses a <code>VkSampler</code> object that uses unnormalized coordinates, that sampler <strong class=\"purple\">must</strong> not be used with any of the SPIR-V <code>OpImageSample*</code> or <code>OpImageSparseSample*</code> instructions that includes a LOD bias or any offset values, in any shader stage"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02705",
+ "text": " If the <a href=\"#features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and if the <code>VkPipeline</code> object bound to the pipeline bind point used by this command accesses a uniform buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02706",
+ "text": " If the <a href=\"#features-robustBufferAccess\">robust buffer access</a> feature is not enabled, and if the <code>VkPipeline</code> object bound to the pipeline bind point used by this command accesses a storage buffer, it <strong class=\"purple\">must</strong> not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-renderPass-02684",
+ "text": " The current render pass <strong class=\"purple\">must</strong> be <a href=\"#renderpass-compatibility\">compatible</a> with the <code>renderPass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-subpass-02685",
+ "text": " The subpass index of the current render pass <strong class=\"purple\">must</strong> be equal to the <code>subpass</code> member of the <code>VkGraphicsPipelineCreateInfo</code> structure specified when creating the <code>VkPipeline</code> bound to <code>VK_PIPELINE_BIND_POINT_GRAPHICS</code>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02686",
+ "text": " Every input attachment used by the current subpass <strong class=\"purple\">must</strong> be bound to the pipeline via a descriptor set"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02687",
+ "text": " Image subresources used as attachments in the current render pass <strong class=\"purple\">must</strong> not be accessed in any way other than as an attachment by this command."
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02720",
+ "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface <strong class=\"purple\">must</strong> have valid buffers bound"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02721",
+ "text": " For a given vertex buffer binding, any attribute data fetched <strong class=\"purple\">must</strong> be entirely contained within the corresponding vertex buffer binding, as described in <a href=\"#fxvertex-input\">Vertex Input Description</a>"
+ },
+ {
"vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-isPreprocessed-02908",
- "text": " If <code>isPreprocessed</code> is <code>VK_TRUE</code> then <a href=\"#vkCmdPreprocessGeneratedCommandsNV\">vkCmdPreprocessGeneratedCommandsNV</a> <strong class=\"purple\">must</strong> have already been executed on the device, using the same <code>pGeneratedCommandsInfo</code> content as well as the content of the input buffers it references (all except <a href=\"#VkGeneratedCommandsInfoNV\">VkGeneratedCommandsInfoNV</a>::<code>preprocessBuffer</code>). Furthermore <code>pGeneratedCommandsInfo</code>`s <code>indirectCommandsLayout</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV</code> bit set."
+ "text": " If <code>isPreprocessed</code> is <code>VK_TRUE</code> then <a href=\"#vkCmdPreprocessGeneratedCommandsNV\">vkCmdPreprocessGeneratedCommandsNV</a> <strong class=\"purple\">must</strong> have already been executed on the device, using the same <code>pGeneratedCommandsInfo</code> content as well as the content of the input buffers it references (all except <a href=\"#VkGeneratedCommandsInfoNV\">VkGeneratedCommandsInfoNV</a>::<code>preprocessBuffer</code>). Furthermore <code>pGeneratedCommandsInfo</code>`s <code>indirectCommandsLayout</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV</code> bit set"
},
{
"vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pipeline-02909",
},
{
"vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-deviceGeneratedCommands-02911",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-parameter",
"text": " This command <strong class=\"purple\">must</strong> only be called inside of a render pass instance"
}
],
+ "(VK_NV_device_generated_commands)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02692",
+ "text": " If a <code>VkImageView</code> is sampled with <code>VK_FILTER_CUBIC_EXT</code> as a result of this command, then the image view’s <a href=\"#resources-image-view-format-features\">format features</a> <strong class=\"purple\">must</strong> contain <code>VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT</code>"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02693",
+ "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_EXT</code> as a result of this command <strong class=\"purple\">must</strong> not have a <a href=\"#VkImageViewType\">VkImageViewType</a> of <code>VK_IMAGE_VIEW_TYPE_3D</code>, <code>VK_IMAGE_VIEW_TYPE_CUBE</code>, or <code>VK_IMAGE_VIEW_TYPE_CUBE_ARRAY</code>"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-filterCubic-02694",
+ "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_EXT</code> as a result of this command <strong class=\"purple\">must</strong> have a <a href=\"#VkImageViewType\">VkImageViewType</a> and format that supports cubic filtering, as specified by <code>VkFilterCubicImageViewImageFormatPropertiesEXT</code>::<code>filterCubic</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties2</code>"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-filterCubicMinmax-02695",
+ "text": " Any <a href=\"#VkImageView\">VkImageView</a> being sampled with <code>VK_FILTER_CUBIC_EXT</code> with a reduction mode of either <code>VK_SAMPLER_REDUCTION_MODE_MIN</code> or <code>VK_SAMPLER_REDUCTION_MODE_MAX</code> as a result of this command <strong class=\"purple\">must</strong> have a <a href=\"#VkImageViewType\">VkImageViewType</a> and format that supports cubic filtering together with minmax filtering, as specified by <code>VkFilterCubicImageViewImageFormatPropertiesEXT</code>::<code>filterCubicMinmax</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties2</code>"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_NV_corner_sampled_image)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-flags-02696",
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02707",
+ "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
+ },
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02970",
+ "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_VERSION_1_1,VK_KHR_multiview)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-maxMultiviewInstanceIndex-02688",
+ "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMultiviewProperties\">VkPhysicalDeviceMultiviewProperties</a>::<code>maxMultiviewInstanceIndex</code>"
+ }
+ ],
+ "(VK_NV_device_generated_commands)+(VK_EXT_sample_locations)": [
+ {
+ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-sampleLocationsEnable-02689",
+ "text": " If the bound graphics pipeline was created with <a href=\"#VkPipelineSampleLocationsStateCreateInfoEXT\">VkPipelineSampleLocationsStateCreateInfoEXT</a>::<code>sampleLocationsEnable</code> set to <code>VK_TRUE</code> and the current subpass has a depth/stencil attachment, then that attachment <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT</code> bit set"
+ }
+ ],
"(VK_NV_device_generated_commands)+(VK_EXT_transform_feedback)": [
{
"vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02910",
- "text": " Transform feedback <strong class=\"purple\">must</strong> not be active."
+ "text": " Transform feedback <strong class=\"purple\">must</strong> not be active"
}
]
},
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-pipeline-02912",
- "text": " The provided <code>pipeline</code> <strong class=\"purple\">must</strong> match the pipeline bound at execution time."
+ "text": " The provided <code>pipeline</code> <strong class=\"purple\">must</strong> match the pipeline bound at execution time"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-02913",
- "text": " If the <code>indirectCommandsLayout</code> uses a token of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV</code>, then the <code>pipeline</code> <strong class=\"purple\">must</strong> have been created with multiple shader groups."
+ "text": " If the <code>indirectCommandsLayout</code> uses a token of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV</code>, then the <code>pipeline</code> <strong class=\"purple\">must</strong> have been created with multiple shader groups"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-02914",
- "text": " If the <code>indirectCommandsLayout</code> uses a token of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV</code>, then the <code>pipeline</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV</code> set in <code>VkGraphicsPipelineCreateInfo</code>::<code>flags</code>."
+ "text": " If the <code>indirectCommandsLayout</code> uses a token of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV</code>, then the <code>pipeline</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV</code> set in <code>VkGraphicsPipelineCreateInfo</code>::<code>flags</code>"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-02915",
- "text": " If the <code>indirectCommandsLayout</code> uses a token of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, then the <code>pipeline</code>`s <code>VkPipelineLayout</code> <strong class=\"purple\">must</strong> match the <a href=\"#VkIndirectCommandsLayoutTokenNV\">VkIndirectCommandsLayoutTokenNV</a>::<code>pushconstantPipelineLayout</code>."
+ "text": " If the <code>indirectCommandsLayout</code> uses a token of <code>VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV</code>, then the <code>pipeline</code>`s <code>VkPipelineLayout</code> <strong class=\"purple\">must</strong> match the <a href=\"#VkIndirectCommandsLayoutTokenNV\">VkIndirectCommandsLayoutTokenNV</a>::<code>pushconstantPipelineLayout</code>"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-streamCount-02916",
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCount-02917",
- "text": " <code>sequencesCount</code> <strong class=\"purple\">must</strong> be less or equal to <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>::<code>maxIndirectSequenceCount</code> and <a href=\"#VkGeneratedCommandsMemoryRequirementsInfoNV\">VkGeneratedCommandsMemoryRequirementsInfoNV</a>::<code>maxSequencesCount</code> that was used to determine the <code>preprocessSize</code>."
+ "text": " <code>sequencesCount</code> <strong class=\"purple\">must</strong> be less or equal to <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>::<code>maxIndirectSequenceCount</code> and <a href=\"#VkGeneratedCommandsMemoryRequirementsInfoNV\">VkGeneratedCommandsMemoryRequirementsInfoNV</a>::<code>maxSequencesCount</code> that was used to determine the <code>preprocessSize</code>"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessBuffer-02918",
- "text": " <code>preprocessBuffer</code> <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set in its usage flag."
+ "text": " <code>preprocessBuffer</code> <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set in its usage flag"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessOffset-02919",
- "text": " <code>preprocessOffset</code> <strong class=\"purple\">must</strong> be aligned to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::<code>minIndirectCommandsBufferOffsetAlignment</code>"
+ "text": " <code>preprocessOffset</code> <strong class=\"purple\">must</strong> be aligned to <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\">VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</a>::<code>minIndirectCommandsBufferOffsetAlignment</code>"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessBuffer-02971",
+ "text": " If <code>preprocessBuffer</code> is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessSize-02920",
- "text": " <code>preprocessSize</code> <strong class=\"purple\">must</strong> be at least equal to the memory requirement`s size returned by <a href=\"#vkGetGeneratedCommandsMemoryRequirementsNV\">vkGetGeneratedCommandsMemoryRequirementsNV</a> using the matching inputs (<code>indirectCommandsLayout</code>, …​) as within this structure."
+ "text": " <code>preprocessSize</code> <strong class=\"purple\">must</strong> be at least equal to the memory requirement`s size returned by <a href=\"#vkGetGeneratedCommandsMemoryRequirementsNV\">vkGetGeneratedCommandsMemoryRequirementsNV</a> using the matching inputs (<code>indirectCommandsLayout</code>, …​) as within this structure"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02921",
- "text": " <code>sequencesCountBuffer</code> <strong class=\"purple\">can</strong> be set if the actual used count of sequences is sourced from the provided buffer. In that case the <code>sequencesCount</code> serves as upper bound."
+ "text": " <code>sequencesCountBuffer</code> <strong class=\"purple\">can</strong> be set if the actual used count of sequences is sourced from the provided buffer. In that case the <code>sequencesCount</code> serves as upper bound"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02922",
- "text": " If <code>sequencesCountBuffer</code> is used, its usage flag <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
+ "text": " If <code>sequencesCountBuffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, its usage flag <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02923",
- "text": " If <code>sequencesCountBuffer</code> is used, <code>sequencesCountOffset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minSequencesCountBufferOffsetAlignment</code>"
+ "text": " If <code>sequencesCountBuffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>sequencesCountOffset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minSequencesCountBufferOffsetAlignment</code>"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02972",
+ "text": " If <code>sequencesCountBuffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02924",
- "text": " <code>sequencesIndexBuffer</code> <strong class=\"purple\">must</strong> be set if <code>indirectCommandsLayout</code>’s <code>VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV</code> is set, otherwise it <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>."
+ "text": " If <code>indirectCommandsLayout</code>’s <code>VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV</code> is set, <code>sequencesIndexBuffer</code> <strong class=\"purple\">must</strong> be set otherwise it <strong class=\"purple\">must</strong> be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02925",
- "text": " If <code>sequencesIndexBuffer</code> is used, its usage flag <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
+ "text": " If <code>sequencesIndexBuffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, its usage flag <strong class=\"purple\">must</strong> have the <code>VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT</code> bit set"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02926",
- "text": " If <code>sequencesIndexBuffer</code> is used, <code>sequencesIndexOffset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minSequencesIndexBufferOffsetAlignment</code>"
+ "text": " If <code>sequencesIndexBuffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>sequencesIndexOffset</code> <strong class=\"purple\">must</strong> be aligned to <code>VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV</code>::<code>minSequencesIndexBufferOffsetAlignment</code>"
+ },
+ {
+ "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02973",
+ "text": " If <code>sequencesIndexBuffer</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a> and is non-sparse then it <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object"
},
{
"vuid": "VUID-VkGeneratedCommandsInfoNV-sType-sType",
]
},
"vkCmdPreprocessGeneratedCommandsNV": {
+ "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [
+ {
+ "vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-commandBuffer-02974",
+ "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
+ }
+ ],
"(VK_NV_device_generated_commands)": [
{
"vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-pGeneratedCommandsInfo-02927",
- "text": " <code>pGeneratedCommandsInfo</code>`s <code>indirectCommandsLayout</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV</code> bit set."
+ "text": " <code>pGeneratedCommandsInfo</code>`s <code>indirectCommandsLayout</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV</code> bit set"
},
{
"vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-deviceGeneratedCommands-02928",
- "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>→<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-device-generated-commands\"><code>VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</code>::<code>deviceGeneratedCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-commandBuffer-parameter",
"core": [
{
"vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094",
- "text": " <code>samples</code> <strong class=\"purple\">must</strong> be a bit value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command and <code>flags</code> equal to the value that is set in <code>VkImageCreateInfo</code>::<code>flags</code> when the image is created"
+ "text": " <code>samples</code> <strong class=\"purple\">must</strong> be a bit value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command and <code>flags</code> equal to the value that is set in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> when the image is created"
},
{
"vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter",
"(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [
{
"vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095",
- "text": " <code>samples</code> <strong class=\"purple\">must</strong> be a bit value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command and <code>flags</code> equal to the value that is set in <code>VkImageCreateInfo</code>::<code>flags</code> when the image is created"
+ "text": " <code>samples</code> <strong class=\"purple\">must</strong> be a bit value that is set in <code>VkImageFormatProperties</code>::<code>sampleCounts</code> returned by <code>vkGetPhysicalDeviceImageFormatProperties</code> with <code>format</code>, <code>type</code>, <code>tiling</code>, and <code>usage</code> equal to those in this command and <code>flags</code> equal to the value that is set in <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> when the image is created"
},
{
"vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-sType-sType",
"(VK_VERSION_1_1,VK_KHR_external_memory)": [
{
"vuid": "VUID-VkSparseMemoryBind-memory-02730",
- "text": " If <code>memory</code> was created with <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> not equal to <code>0</code>, at least one handle type it contained <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> or <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when the resource was created."
+ "text": " If <code>memory</code> was created with <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> not equal to <code>0</code>, at least one handle type it contained <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> or <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when the resource was created"
},
{
"vuid": "VUID-VkSparseMemoryBind-memory-02731",
- "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> or <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when the resource was created."
+ "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> or <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when the resource was created"
}
]
},
"(VK_VERSION_1_1,VK_KHR_external_memory)": [
{
"vuid": "VUID-VkSparseImageMemoryBind-memory-02732",
- "text": " If <code>memory</code> was created with <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> not equal to <code>0</code>, at least one handle type it contained <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when the image was created."
+ "text": " If <code>memory</code> was created with <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> not equal to <code>0</code>, at least one handle type it contained <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when the image was created"
},
{
"vuid": "VUID-VkSparseImageMemoryBind-memory-02733",
- "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created."
+ "text": " If <code>memory</code> was created by a memory import operation, the external handle type of the imported memory <strong class=\"purple\">must</strong> also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
}
]
},
},
{
"vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01116",
- "text": " When a semaphore wait operation referring to a binary semaphore defined by any element of the <code>pWaitSemaphores</code> member of any element of <code>pBindInfo</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore."
+ "text": " When a semaphore wait operation referring to a binary semaphore defined by any element of the <code>pWaitSemaphores</code> member of any element of <code>pBindInfo</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore"
},
{
"vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117",
"(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [
{
"vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-03245",
- "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of <code>pBindInfo</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_BINARY</code> <strong class=\"purple\">must</strong> reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution."
+ "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of <code>pBindInfo</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_BINARY</code> <strong class=\"purple\">must</strong> reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution"
}
]
},
},
{
"vuid": "VUID-VkBindSparseInfo-pWaitSemaphores-03250",
- "text": " For each element of <code>pWaitSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pWaitSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>."
+ "text": " For each element of <code>pWaitSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pWaitSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>"
},
{
"vuid": "VUID-VkBindSparseInfo-pSignalSemaphores-03251",
- "text": " For each element of <code>pSignalSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pSignalSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>."
+ "text": " For each element of <code>pSignalSemaphores</code> created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_TIMELINE</code> the corresponding element of <a href=\"#VkTimelineSemaphoreSubmitInfo\">VkTimelineSemaphoreSubmitInfo</a>::pSignalSemaphoreValues <strong class=\"purple\">must</strong> have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than <a href=\"#limits-maxTimelineSemaphoreValueDifference\"><code>maxTimelineSemaphoreValueDifference</code></a>"
}
],
"core": [
"(VK_VERSION_1_1,VK_KHR_device_group)": [
{
"vuid": "VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118",
- "text": " <code>resourceDeviceIndex</code> and <code>memoryDeviceIndex</code> <strong class=\"purple\">must</strong> both be valid device indices."
+ "text": " <code>resourceDeviceIndex</code> and <code>memoryDeviceIndex</code> <strong class=\"purple\">must</strong> both be valid device indices"
},
{
"vuid": "VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119",
- "text": " Each memory allocation bound in this batch <strong class=\"purple\">must</strong> have allocated an instance for <code>memoryDeviceIndex</code>."
+ "text": " Each memory allocation bound in this batch <strong class=\"purple\">must</strong> have allocated an instance for <code>memoryDeviceIndex</code>"
},
{
"vuid": "VUID-VkDeviceGroupBindSparseInfo-sType-sType",
"(VK_KHR_surface)+(VK_KHR_android_surface)": [
{
"vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-window-01248",
- "text": " <code>window</code> <strong class=\"purple\">must</strong> point to a valid Android <a href=\"#ANativeWindow\">ANativeWindow</a>."
+ "text": " <code>window</code> <strong class=\"purple\">must</strong> point to a valid Android <a href=\"#ANativeWindow\">ANativeWindow</a>"
},
{
"vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-sType-sType",
"(VK_KHR_surface)+(VK_KHR_wayland_surface)": [
{
"vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-display-01304",
- "text": " <code>display</code> <strong class=\"purple\">must</strong> point to a valid Wayland <code>wl_display</code>."
+ "text": " <code>display</code> <strong class=\"purple\">must</strong> point to a valid Wayland <code>wl_display</code>"
},
{
"vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305",
- "text": " <code>surface</code> <strong class=\"purple\">must</strong> point to a valid Wayland <code>wl_surface</code>."
+ "text": " <code>surface</code> <strong class=\"purple\">must</strong> point to a valid Wayland <code>wl_surface</code>"
},
{
"vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType",
"(VK_KHR_surface)+(VK_KHR_win32_surface)": [
{
"vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307",
- "text": " <code>hinstance</code> <strong class=\"purple\">must</strong> be a valid Win32 <code>HINSTANCE</code>."
+ "text": " <code>hinstance</code> <strong class=\"purple\">must</strong> be a valid Win32 <code>HINSTANCE</code>"
},
{
"vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308",
- "text": " <code>hwnd</code> <strong class=\"purple\">must</strong> be a valid Win32 <code>HWND</code>."
+ "text": " <code>hwnd</code> <strong class=\"purple\">must</strong> be a valid Win32 <code>HWND</code>"
},
{
"vuid": "VUID-VkWin32SurfaceCreateInfoKHR-sType-sType",
"(VK_KHR_surface)+(VK_KHR_xcb_surface)": [
{
"vuid": "VUID-VkXcbSurfaceCreateInfoKHR-connection-01310",
- "text": " <code>connection</code> <strong class=\"purple\">must</strong> point to a valid X11 <code>xcb_connection_t</code>."
+ "text": " <code>connection</code> <strong class=\"purple\">must</strong> point to a valid X11 <code>xcb_connection_t</code>"
},
{
"vuid": "VUID-VkXcbSurfaceCreateInfoKHR-window-01311",
- "text": " <code>window</code> <strong class=\"purple\">must</strong> be a valid X11 <code>xcb_window_t</code>."
+ "text": " <code>window</code> <strong class=\"purple\">must</strong> be a valid X11 <code>xcb_window_t</code>"
},
{
"vuid": "VUID-VkXcbSurfaceCreateInfoKHR-sType-sType",
"(VK_KHR_surface)+(VK_KHR_xlib_surface)": [
{
"vuid": "VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313",
- "text": " <code>dpy</code> <strong class=\"purple\">must</strong> point to a valid Xlib <code>Display</code>."
+ "text": " <code>dpy</code> <strong class=\"purple\">must</strong> point to a valid Xlib <code>Display</code>"
},
{
"vuid": "VUID-VkXlibSurfaceCreateInfoKHR-window-01314",
- "text": " <code>window</code> <strong class=\"purple\">must</strong> be a valid Xlib <code>Window</code>."
+ "text": " <code>window</code> <strong class=\"purple\">must</strong> be a valid Xlib <code>Window</code>"
},
{
"vuid": "VUID-VkXlibSurfaceCreateInfoKHR-sType-sType",
"(VK_KHR_surface)+(VK_MVK_ios_surface)": [
{
"vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pView-01316",
- "text": " <code>pView</code> <strong class=\"purple\">must</strong> be a valid <code>UIView</code> and <strong class=\"purple\">must</strong> be backed by a <code>CALayer</code> instance of type <a href=\"#CAMetalLayer\">CAMetalLayer</a>."
+ "text": " <code>pView</code> <strong class=\"purple\">must</strong> be a valid <code>UIView</code> and <strong class=\"purple\">must</strong> be backed by a <code>CALayer</code> instance of type <a href=\"#CAMetalLayer\">CAMetalLayer</a>"
},
{
"vuid": "VUID-VkIOSSurfaceCreateInfoMVK-sType-sType",
"(VK_KHR_surface)+(VK_MVK_macos_surface)": [
{
"vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317",
- "text": " <code>pView</code> <strong class=\"purple\">must</strong> be a valid <code>NSView</code> and <strong class=\"purple\">must</strong> be backed by a <code>CALayer</code> instance of type <a href=\"#CAMetalLayer\">CAMetalLayer</a>."
+ "text": " <code>pView</code> <strong class=\"purple\">must</strong> be a valid <code>NSView</code> and <strong class=\"purple\">must</strong> be backed by a <code>CALayer</code> instance of type <a href=\"#CAMetalLayer\">CAMetalLayer</a>"
},
{
"vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-sType-sType",
"(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [
{
"vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pNext-02671",
- "text": " If a <a href=\"#VkSurfaceCapabilitiesFullScreenExclusiveEXT\">VkSurfaceCapabilitiesFullScreenExclusiveEXT</a> structure is included in the <code>pNext</code> chain of <code>pSurfaceCapabilities</code>, a <a href=\"#VkSurfaceFullScreenExclusiveWin32InfoEXT\">VkSurfaceFullScreenExclusiveWin32InfoEXT</a> structure <strong class=\"purple\">must</strong> be included in the <code>pNext</code> chain of <code>pSurfaceInfo</code>."
+ "text": " If a <a href=\"#VkSurfaceCapabilitiesFullScreenExclusiveEXT\">VkSurfaceCapabilitiesFullScreenExclusiveEXT</a> structure is included in the <code>pNext</code> chain of <code>pSurfaceCapabilities</code>, a <a href=\"#VkSurfaceFullScreenExclusiveWin32InfoEXT\">VkSurfaceFullScreenExclusiveWin32InfoEXT</a> structure <strong class=\"purple\">must</strong> be included in the <code>pNext</code> chain of <code>pSurfaceInfo</code>"
}
],
"(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [
"(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [
{
"vuid": "VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246",
- "text": " <code>supportedSurfaceCounters</code> <strong class=\"purple\">must</strong> not include <code>VK_SURFACE_COUNTER_VBLANK_EXT</code> unless the surface queried is a <a href=\"#wsi-display-surfaces\">display surface</a>."
+ "text": " <code>supportedSurfaceCounters</code> <strong class=\"purple\">must</strong> not include <code>VK_SURFACE_COUNTER_VBLANK_EXT</code> unless the surface queried is a <a href=\"#wsi-display-surfaces\">display surface</a>"
},
{
"vuid": "VUID-VkSurfaceCapabilities2EXT-sType-sType",
"(VK_KHR_surface)": [
{
"vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-02739",
- "text": " <code>surface</code> must be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism."
+ "text": " <code>surface</code> must be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
},
{
"vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter",
"(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [
{
"vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-02740",
- "text": " <code>pSurfaceInfo->surface</code> must be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism."
+ "text": " <code>pSurfaceInfo->surface</code> must be supported by <code>physicalDevice</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceSupportKHR\">vkGetPhysicalDeviceSurfaceSupportKHR</a> or an equivalent platform-specific mechanism"
},
{
"vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter",
},
{
"vuid": "VUID-VkSwapchainDisplayNativeHdrCreateInfoAMD-localDimmingEnable-XXXXX",
- "text": " It is only valid to set <code>localDimmingEnable</code> to <code>VK_TRUE</code> if <a href=\"#VkDisplayNativeHdrSurfaceCapabilitiesAMD\">VkDisplayNativeHdrSurfaceCapabilitiesAMD</a>::<code>localDimmingSupport</code> is supported."
+ "text": " It is only valid to set <code>localDimmingEnable</code> to <code>VK_TRUE</code> if <a href=\"#VkDisplayNativeHdrSurfaceCapabilitiesAMD\">VkDisplayNativeHdrSurfaceCapabilitiesAMD</a>::<code>localDimmingSupport</code> is supported"
}
]
},
},
{
"vuid": "VUID-vkSetLocalDimmingAMD-XXXXX",
- "text": " It is only valid to call <a href=\"#vkSetLocalDimmingAMD\">vkSetLocalDimmingAMD</a> if <a href=\"#VkDisplayNativeHdrSurfaceCapabilitiesAMD\">VkDisplayNativeHdrSurfaceCapabilitiesAMD</a>::<code>localDimmingSupport</code> is supported."
+ "text": " It is only valid to call <a href=\"#vkSetLocalDimmingAMD\">vkSetLocalDimmingAMD</a> if <a href=\"#VkDisplayNativeHdrSurfaceCapabilitiesAMD\">VkDisplayNativeHdrSurfaceCapabilitiesAMD</a>::<code>localDimmingSupport</code> is supported"
}
]
},
"(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [
{
"vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244",
- "text": " The bits in <code>surfaceCounters</code> <strong class=\"purple\">must</strong> be supported by <a href=\"#VkSwapchainCreateInfoKHR\">VkSwapchainCreateInfoKHR</a>::<code>surface</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceCapabilities2EXT\">vkGetPhysicalDeviceSurfaceCapabilities2EXT</a>."
+ "text": " The bits in <code>surfaceCounters</code> <strong class=\"purple\">must</strong> be supported by <a href=\"#VkSwapchainCreateInfoKHR\">VkSwapchainCreateInfoKHR</a>::<code>surface</code>, as reported by <a href=\"#vkGetPhysicalDeviceSurfaceCapabilities2EXT\">vkGetPhysicalDeviceSurfaceCapabilities2EXT</a>"
},
{
"vuid": "VUID-VkSwapchainCounterCreateInfoEXT-sType-sType",
"(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [
{
"vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-01245",
- "text": " One or more present commands on <code>swapchain</code> <strong class=\"purple\">must</strong> have been processed by the presentation engine."
+ "text": " One or more present commands on <code>swapchain</code> <strong class=\"purple\">must</strong> have been processed by the presentation engine"
},
{
"vuid": "VUID-vkGetSwapchainCounterEXT-device-parameter",
},
{
"vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01294",
- "text": " When a semaphore wait operation referring to a binary semaphore defined by the elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore."
+ "text": " When a semaphore wait operation referring to a binary semaphore defined by the elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore"
},
{
"vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01295",
"(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [
{
"vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-03267",
- "text": " All elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> <strong class=\"purple\">must</strong> be created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_BINARY</code>."
+ "text": " All elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> <strong class=\"purple\">must</strong> be created with a <a href=\"#VkSemaphoreType\">VkSemaphoreType</a> of <code>VK_SEMAPHORE_TYPE_BINARY</code>"
},
{
"vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-03268",
- "text": " All elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> <strong class=\"purple\">must</strong> reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution."
+ "text": " All elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> <strong class=\"purple\">must</strong> reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution"
}
]
},
"(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [
{
"vuid": "VUID-VkRectLayerKHR-offset-01261",
- "text": " The sum of <code>offset</code> and <code>extent</code> <strong class=\"purple\">must</strong> be no greater than the <code>imageExtent</code> member of the <code>VkSwapchainCreateInfoKHR</code> structure given to <a href=\"#vkCreateSwapchainKHR\">vkCreateSwapchainKHR</a>."
+ "text": " The sum of <code>offset</code> and <code>extent</code> <strong class=\"purple\">must</strong> be no greater than the <code>imageExtent</code> member of the <a href=\"#VkSwapchainCreateInfoKHR\">VkSwapchainCreateInfoKHR</a> structure passed to <a href=\"#vkCreateSwapchainKHR\">vkCreateSwapchainKHR</a>"
},
{
"vuid": "VUID-VkRectLayerKHR-layer-01262",
- "text": " <code>layer</code> <strong class=\"purple\">must</strong> be less than <code>imageArrayLayers</code> member of the <code>VkSwapchainCreateInfoKHR</code> structure given to <a href=\"#vkCreateSwapchainKHR\">vkCreateSwapchainKHR</a>."
+ "text": " <code>layer</code> <strong class=\"purple\">must</strong> be less than the <code>imageArrayLayers</code> member of the <a href=\"#VkSwapchainCreateInfoKHR\">VkSwapchainCreateInfoKHR</a> structure passed to <a href=\"#vkCreateSwapchainKHR\">vkCreateSwapchainKHR</a>"
}
]
},
},
{
"vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01299",
- "text": " If <code>mode</code> is <code>VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR</code>, then each element of <code>pDeviceMasks</code> <strong class=\"purple\">must</strong> have exactly one bit set, and some physical device in the logical device <strong class=\"purple\">must</strong> include that bit in its <a href=\"#VkDeviceGroupPresentCapabilitiesKHR\">VkDeviceGroupPresentCapabilitiesKHR</a>::<code>presentMask</code>."
+ "text": " If <code>mode</code> is <code>VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR</code>, then each element of <code>pDeviceMasks</code> <strong class=\"purple\">must</strong> have exactly one bit set, and some physical device in the logical device <strong class=\"purple\">must</strong> include that bit in its <a href=\"#VkDeviceGroupPresentCapabilitiesKHR\">VkDeviceGroupPresentCapabilitiesKHR</a>::<code>presentMask</code>"
},
{
"vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01300",
"(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [
{
"vuid": "VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247",
- "text": " <code>swapchainCount</code> <strong class=\"purple\">must</strong> be the same value as <code>VkPresentInfoKHR</code>::<code>swapchainCount</code>, where <code>VkPresentInfoKHR</code> is included in the <code>pNext</code> chain of this <code>VkPresentTimesInfoGOOGLE</code> structure."
+ "text": " <code>swapchainCount</code> <strong class=\"purple\">must</strong> be the same value as <code>VkPresentInfoKHR</code>::<code>swapchainCount</code>, where <code>VkPresentInfoKHR</code> is included in the <code>pNext</code> chain of this <code>VkPresentTimesInfoGOOGLE</code> structure"
},
{
"vuid": "VUID-VkPresentTimesInfoGOOGLE-sType-sType",
},
{
"vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03435",
- "text": " If no <code>VkAllocationCallbacks</code> were provided when <code>operation</code> was created, <code>pAllocator</code> <strong class=\"purple\">must</strong> be NULL"
+ "text": " If no <code>VkAllocationCallbacks</code> were provided when <code>operation</code> was created, <code>pAllocator</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
},
{
"vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03436",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_NV_ray_tracing)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdTraceRaysNV-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_NV_ray_tracing)+(VK_VERSION_1_1)": [
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdTraceRaysKHR-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_VERSION_1_1)": [
},
{
"vuid": "VUID-vkCmdTraceRaysIndirectKHR-rayTracingIndirectTraceRays-03518",
- "text": " the <a href=\"#features-raytracing-indirecttraceray\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingIndirectTraceRays</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " the <a href=\"#features-raytracing-indirecttraceray\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingIndirectTraceRays</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-parameter",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_NV_corner_sampled_image)": [
{
"vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-02696",
- "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>."
+ "text": " Any <a href=\"#VkImage\">VkImage</a> created with a <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> containing <code>VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV</code> sampled as a result of this command <strong class=\"purple\">must</strong> only be sampled using a <a href=\"#VkSamplerAddressMode\">VkSamplerAddressMode</a> of <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE</code>"
}
],
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_VERSION_1_1)": [
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureNV-dst-02488",
- "text": " <code>dst</code> <strong class=\"purple\">must</strong> have been created with compatible <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a> where <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>type</code> and <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>flags</code> are identical, <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>instanceCount</code> and <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>geometryCount</code> for <code>dst</code> are greater than or equal to the build size and each geometry in <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>pGeometries</code> for <code>dst</code> has greater than or equal to the number of vertices, indices, and AABBs."
+ "text": " <code>dst</code> <strong class=\"purple\">must</strong> have been created with compatible <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a> where <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>type</code> and <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>flags</code> are identical, <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>instanceCount</code> and <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>geometryCount</code> for <code>dst</code> are greater than or equal to the build size and each geometry in <a href=\"#VkAccelerationStructureInfoNV\">VkAccelerationStructureInfoNV</a>::<code>pGeometries</code> for <code>dst</code> has greater than or equal to the number of vertices, indices, and AABBs"
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02489",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pOffsetInfos-03402",
- "text": " <code>pOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i]→<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
+ "text": " <code>pOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i].<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pInfos-03403",
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pInfos-03404",
- "text": " For each <code>pInfos</code>[i], <code>dstAccelerationStructure</code> <strong class=\"purple\">must</strong> have been created with compatible <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a> where <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>flags</code> are identical to <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>flags</code> respectively, <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>geometryCount</code> for <code>dstAccelerationStructure</code> are greater than or equal to the build size, and each geometry in <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>ppGeometries</code> for <code>dstAccelerationStructure</code> has greater than or equal to the number of vertices, indices, and AABBs, <a href=\"#VkAccelerationStructureGeometryTrianglesDataKHR\">VkAccelerationStructureGeometryTrianglesDataKHR</a>::<code>transformData</code> is both 0 or both non-zero, and all other parameters are the same."
+ "text": " For each <code>pInfos</code>[i], <code>dstAccelerationStructure</code> <strong class=\"purple\">must</strong> have been created with compatible <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a> where <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>flags</code> are identical to <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>flags</code> respectively, <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>geometryCount</code> for <code>dstAccelerationStructure</code> are greater than or equal to the build size, and each geometry in <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>ppGeometries</code> for <code>dstAccelerationStructure</code> has greater than or equal to the number of vertices, indices, and AABBs, <a href=\"#VkAccelerationStructureGeometryTrianglesDataKHR\">VkAccelerationStructureGeometryTrianglesDataKHR</a>::<code>transformData</code> is both 0 or both non-zero, and all other parameters are the same"
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pInfos-03405",
"(VK_KHR_deferred_host_operations)": [
{
"vuid": "VUID-vkCmdBuildAccelerationStructureKHR-pNext-03532",
- "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of any of the provided <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a> structures."
+ "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of any of the provided <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a> structures"
}
]
},
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureIndirectKHR-rayTracingIndirectAccelerationStructureBuild-03535",
- "text": " The <a href=\"#features-raytracing-indirectasbuild\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingIndirectAccelerationStructureBuild</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#features-raytracing-indirectasbuild\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingIndirectAccelerationStructureBuild</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCmdBuildAccelerationStructureIndirectKHR-commandBuffer-parameter",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_KHR_deferred_host_operations)": [
{
"vuid": "VUID-vkCmdBuildAccelerationStructureIndirectKHR-pNext-03536",
- "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of any of the provided <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a> structures."
+ "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of any of the provided <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a> structures"
}
]
},
},
{
"vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-update-03540",
- "text": " If <code>update</code> is
enam:VK_TRUE, the <code>srcAccelerationStructure</code> and <code>dstAccelerationStructure</code> objects <strong class=\"purple\">must</strong> either be the same object or not have any <a href=\"#resources-memory-aliasing\">memory aliasing</a>"
+ "text": " If <code>update</code> is
<code>VK_TRUE</code>, the <code>srcAccelerationStructure</code> and <code>dstAccelerationStructure</code> objects <strong class=\"purple\">must</strong> either be the same object or not have any <a href=\"#resources-memory-aliasing\">memory aliasing</a>"
},
{
"vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-sType-sType",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_ray_tracing)+(VK_KHR_deferred_host_operations)": [
{
"vuid": "VUID-vkCmdCopyAccelerationStructureKHR-pNext-03557",
- "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of the <a href=\"#VkCopyAccelerationStructureInfoKHR\">VkCopyAccelerationStructureInfoKHR</a> structure."
+ "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of the <a href=\"#VkCopyAccelerationStructureInfoKHR\">VkCopyAccelerationStructureInfoKHR</a> structure"
}
]
},
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-None-03558",
- "text": " All <code>VkDeviceOrHostAddressConstKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid device addresses."
+ "text": " All <code>VkDeviceOrHostAddressConstKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid device addresses"
},
{
"vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-None-03559",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_deferred_host_operations)": [
{
"vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-pNext-03560",
- "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of the <a href=\"#VkCopyAccelerationStructureToMemoryInfoKHR\">VkCopyAccelerationStructureToMemoryInfoKHR</a> structure."
+ "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of the <a href=\"#VkCopyAccelerationStructureToMemoryInfoKHR\">VkCopyAccelerationStructureToMemoryInfoKHR</a> structure"
}
]
},
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-None-03562",
- "text": " All <code>VkDeviceOrHostAddressKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid device addresses."
+ "text": " All <code>VkDeviceOrHostAddressKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid device addresses"
},
{
"vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-None-03563",
},
{
"vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-pInfo-03414",
- "text": " The data in <code>pInfo->
pname</code>:src <strong class=\"purple\">must</strong> have a format compatible with the destination physical device as returned by <a href=\"#vkGetDeviceAccelerationStructureCompatibilityKHR\">vkGetDeviceAccelerationStructureCompatibilityKHR</a>"
+ "text": " The data in <code>pInfo->
src</code> <strong class=\"purple\">must</strong> have a format compatible with the destination physical device as returned by <a href=\"#vkGetDeviceAccelerationStructureCompatibilityKHR\">vkGetDeviceAccelerationStructureCompatibilityKHR</a>"
},
{
"vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-commandBuffer-parameter",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)+(VK_KHR_deferred_host_operations)": [
{
"vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-pNext-03564",
- "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of the <a href=\"#VkCopyMemoryToAccelerationStructureInfoKHR\">VkCopyMemoryToAccelerationStructureInfoKHR</a> structure."
+ "text": " The <a href=\"#VkDeferredOperationInfoKHR\">VkDeferredOperationInfoKHR</a> structure <strong class=\"purple\">must</strong> not be included in the <code>pNext</code> chain of the <a href=\"#VkCopyMemoryToAccelerationStructureInfoKHR\">VkCopyMemoryToAccelerationStructureInfoKHR</a> structure"
}
]
},
},
{
"vuid": "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-pInfo-03414",
- "text": " The data in <code>pInfo->
pname</code>:src <strong class=\"purple\">must</strong> have a format compatible with the destination physical device as returned by <a href=\"#vkGetDeviceAccelerationStructureCompatibilityKHR\">vkGetDeviceAccelerationStructureCompatibilityKHR</a>"
+ "text": " The data in <code>pInfo->
src</code> <strong class=\"purple\">must</strong> have a format compatible with the destination physical device as returned by <a href=\"#vkGetDeviceAccelerationStructureCompatibilityKHR\">vkGetDeviceAccelerationStructureCompatibilityKHR</a>"
},
{
"vuid": "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-sType-sType",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkBuildAccelerationStructureKHR-pOffsetInfos-03402",
- "text": " <code>pOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i]→<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
+ "text": " <code>pOffsetInfos</code>[i] <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInfos</code>[i].<code>geometryCount</code> <code>VkAccelerationStructureBuildOffsetInfoKHR</code> structures"
},
{
"vuid": "VUID-vkBuildAccelerationStructureKHR-pInfos-03403",
},
{
"vuid": "VUID-vkBuildAccelerationStructureKHR-pInfos-03404",
- "text": " For each <code>pInfos</code>[i], <code>dstAccelerationStructure</code> <strong class=\"purple\">must</strong> have been created with compatible <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a> where <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>flags</code> are identical to <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>flags</code> respectively, <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>geometryCount</code> for <code>dstAccelerationStructure</code> are greater than or equal to the build size, and each geometry in <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>ppGeometries</code> for <code>dstAccelerationStructure</code> has greater than or equal to the number of vertices, indices, and AABBs, <a href=\"#VkAccelerationStructureGeometryTrianglesDataKHR\">VkAccelerationStructureGeometryTrianglesDataKHR</a>::<code>transformData</code> is both 0 or both non-zero, and all other parameters are the same."
+ "text": " For each <code>pInfos</code>[i], <code>dstAccelerationStructure</code> <strong class=\"purple\">must</strong> have been created with compatible <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a> where <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureCreateInfoKHR\">VkAccelerationStructureCreateInfoKHR</a>::<code>flags</code> are identical to <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>type</code> and <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>flags</code> respectively, <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>geometryCount</code> for <code>dstAccelerationStructure</code> are greater than or equal to the build size, and each geometry in <a href=\"#VkAccelerationStructureBuildGeometryInfoKHR\">VkAccelerationStructureBuildGeometryInfoKHR</a>::<code>ppGeometries</code> for <code>dstAccelerationStructure</code> has greater than or equal to the number of vertices, indices, and AABBs, <a href=\"#VkAccelerationStructureGeometryTrianglesDataKHR\">VkAccelerationStructureGeometryTrianglesDataKHR</a>::<code>transformData</code> is both 0 or both non-zero, and all other parameters are the same"
},
{
"vuid": "VUID-vkBuildAccelerationStructureKHR-pInfos-03405",
},
{
"vuid": "VUID-vkBuildAccelerationStructureKHR-rayTracingHostAccelerationStructureCommands-03439",
- "text": " The <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " The <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
}
]
},
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCopyAccelerationStructureKHR-None-03440",
- "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to host-visible memory."
+ "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to host-visible memory"
},
{
"vuid": "VUID-vkCopyAccelerationStructureKHR-rayTracingHostAccelerationStructureCommands-03441",
- "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCopyAccelerationStructureKHR-device-parameter",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-None-03442",
- "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to host-visible memory."
+ "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to host-visible memory"
},
{
"vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-None-03443",
- "text": " All <code>VkDeviceOrHostAddressConstKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid host pointers."
+ "text": " All <code>VkDeviceOrHostAddressConstKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid host pointers"
},
{
"vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-rayTracingHostAccelerationStructureCommands-03444",
- "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-device-parameter",
"(VK_NV_ray_tracing,VK_KHR_ray_tracing)": [
{
"vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-None-03445",
- "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to host-visible memory."
+ "text": " All <code>VkAccelerationStructureKHR</code> objects referenced by this command <strong class=\"purple\">must</strong> be bound to host-visible memory"
},
{
"vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-None-03446",
- "text": " All <code>VkDeviceOrHostAddressKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid host pointers."
+ "text": " All <code>VkDeviceOrHostAddressKHR</code> referenced by this command <strong class=\"purple\">must</strong> contain valid host pointers"
},
{
"vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-rayTracingHostAccelerationStructureCommands-03447",
- "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
},
{
"vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-device-parameter",
"core": [
{
"vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-rayTracingHostAccelerationStructureCommands-03454",
- "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>→<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+ "text": " the <a href=\"#feature-raytracing-hostascmds\"><code>VkPhysicalDeviceRayTracingFeaturesKHR</code>::<code>rayTracingHostAccelerationStructureCommands</code></a> feature <strong class=\"purple\">must</strong> be enabled"
}
]
},
"(VK_VERSION_1_1,VK_KHR_variable_pointers)": [
{
"vuid": "VUID-VkPhysicalDeviceVariablePointersFeatures-variablePointers-01431",
- "text": " If <code>variablePointers</code> is enabled then <code>variablePointersStorageBuffer</code> <strong class=\"purple\">must</strong> also be enabled."
+ "text": " If <code>variablePointers</code> is enabled then <code>variablePointersStorageBuffer</code> <strong class=\"purple\">must</strong> also be enabled"
},
{
"vuid": "VUID-VkPhysicalDeviceVariablePointersFeatures-sType-sType",
"(VK_VERSION_1_1,VK_KHR_multiview)": [
{
"vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580",
- "text": " If <code>multiviewGeometryShader</code> is enabled then <code>multiview</code> <strong class=\"purple\">must</strong> also be enabled."
+ "text": " If <code>multiviewGeometryShader</code> is enabled then <code>multiview</code> <strong class=\"purple\">must</strong> also be enabled"
},
{
"vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581",
- "text": " If <code>multiviewTessellationShader</code> is enabled then <code>multiview</code> <strong class=\"purple\">must</strong> also be enabled."
+ "text": " If <code>multiviewTessellationShader</code> is enabled then <code>multiview</code> <strong class=\"purple\">must</strong> also be enabled"
},
{
"vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType",
"(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-02248",
- "text": " <code>tiling</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>. (Use <a href=\"#vkGetPhysicalDeviceImageFormatProperties2\">vkGetPhysicalDeviceImageFormatProperties2</a> instead)."
+ "text": " <code>tiling</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code>. (Use <a href=\"#vkGetPhysicalDeviceImageFormatProperties2\">vkGetPhysicalDeviceImageFormatProperties2</a> instead)"
}
],
"core": [
"(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [
{
"vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868",
- "text": " If the <code>pNext</code> chain of <code>pImageFormatProperties</code> includes a <a href=\"#VkAndroidHardwareBufferUsageANDROID\">VkAndroidHardwareBufferUsageANDROID</a> structure, the <code>pNext</code> chain of <code>pImageFormatInfo</code> <strong class=\"purple\">must</strong> include a <a href=\"#VkPhysicalDeviceExternalImageFormatInfo\">VkPhysicalDeviceExternalImageFormatInfo</a> structure with <code>handleType</code> set to <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>."
+ "text": " If the <code>pNext</code> chain of <code>pImageFormatProperties</code> includes a <a href=\"#VkAndroidHardwareBufferUsageANDROID\">VkAndroidHardwareBufferUsageANDROID</a> structure, the <code>pNext</code> chain of <code>pImageFormatInfo</code> <strong class=\"purple\">must</strong> include a <a href=\"#VkPhysicalDeviceExternalImageFormatInfo\">VkPhysicalDeviceExternalImageFormatInfo</a> structure with <code>handleType</code> set to <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [
"(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02249",
- "text": " <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> if and only if the <code>pNext</code> chain includes <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>."
+ "text": " <code>tiling</code> <strong class=\"purple\">must</strong> be <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> if and only if the <code>pNext</code> chain includes <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>"
},
{
"vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02313",
- "text": " If <code>tiling</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> and <code>flags</code> contains <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a> structure with non-zero <code>viewFormatCount</code>."
+ "text": " If <code>tiling</code> is <code>VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT</code> and <code>flags</code> contains <code>VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a <a href=\"#VkImageFormatListCreateInfo\">VkImageFormatListCreateInfo</a> structure with non-zero <code>viewFormatCount</code>"
}
],
"(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [
"(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_image_drm_format_modifier)": [
{
"vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02314",
- "text": " If <code>sharingMode</code> is <code>VK_SHARING_MODE_CONCURRENT</code>, then <code>pQueueFamilyIndices</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>queueFamilyIndexCount</code> <code>uint32_t</code> values."
+ "text": " If <code>sharingMode</code> is <code>VK_SHARING_MODE_CONCURRENT</code>, then <code>pQueueFamilyIndices</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>queueFamilyIndexCount</code> <code>uint32_t</code> values"
},
{
"vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02315",
- "text": " If <code>sharingMode</code> is <code>VK_SHARING_MODE_CONCURRENT</code>, then <code>queueFamilyIndexCount</code> <strong class=\"purple\">must</strong> be greater than <code>1</code>."
+ "text": " If <code>sharingMode</code> is <code>VK_SHARING_MODE_CONCURRENT</code>, then <code>queueFamilyIndexCount</code> <strong class=\"purple\">must</strong> be greater than <code>1</code>"
},
{
"vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02316",
- "text": " If <code>sharingMode</code> is <code>VK_SHARING_MODE_CONCURRENT</code>, each element of <code>pQueueFamilyIndices</code> <strong class=\"purple\">must</strong> be unique and <strong class=\"purple\">must</strong> be less than the <code>pQueueFamilyPropertyCount</code> returned by <a href=\"#vkGetPhysicalDeviceQueueFamilyProperties2\">vkGetPhysicalDeviceQueueFamilyProperties2</a> for the <code>physicalDevice</code> that was used to create <code>device</code>."
+ "text": " If <code>sharingMode</code> is <code>VK_SHARING_MODE_CONCURRENT</code>, each element of <code>pQueueFamilyIndices</code> <strong class=\"purple\">must</strong> be unique and <strong class=\"purple\">must</strong> be less than the <code>pQueueFamilyPropertyCount</code> returned by <a href=\"#vkGetPhysicalDeviceQueueFamilyProperties2\">vkGetPhysicalDeviceQueueFamilyProperties2</a> for the <code>physicalDevice</code> that was used to create <code>device</code>"
},
{
"vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sType-sType",
},
{
"vuid": "VUID-VkFilterCubicImageViewImageFormatPropertiesEXT-pNext-02627",
- "text": " If the <code>pNext</code> chain of the <a href=\"#VkImageFormatProperties2\">VkImageFormatProperties2</a> structure includes a <a href=\"#VkFilterCubicImageViewImageFormatPropertiesEXT\">VkFilterCubicImageViewImageFormatPropertiesEXT</a> structure, the <code>pNext</code> chain of the <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> structure <strong class=\"purple\">must</strong> include a <a href=\"#VkPhysicalDeviceImageViewImageFormatInfoEXT\">VkPhysicalDeviceImageViewImageFormatInfoEXT</a> structure with an <code>imageViewType</code> that is compatible with <code>imageType</code>."
+ "text": " If the <code>pNext</code> chain of the <a href=\"#VkImageFormatProperties2\">VkImageFormatProperties2</a> structure includes a <a href=\"#VkFilterCubicImageViewImageFormatPropertiesEXT\">VkFilterCubicImageViewImageFormatPropertiesEXT</a> structure, the <code>pNext</code> chain of the <a href=\"#VkPhysicalDeviceImageFormatInfo2\">VkPhysicalDeviceImageFormatInfo2</a> structure <strong class=\"purple\">must</strong> include a <a href=\"#VkPhysicalDeviceImageViewImageFormatInfoEXT\">VkPhysicalDeviceImageViewImageFormatInfoEXT</a> structure with an <code>imageViewType</code> that is compatible with <code>imageType</code>"
}
]
},
},
{
"vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter",
- "text": " <code>pObjectName</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string"
+ "text": " If <code>pObjectName</code> is not <code>NULL</code>, <code>pObjectName</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string"
}
]
},
},
{
"vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913",
- "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> be an outstanding <code>vkCmdBeginDebugUtilsLabelEXT</code> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <code>vkCmdEndDebugUtilsLabelEXT</code>."
+ "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> be an outstanding <code>vkCmdBeginDebugUtilsLabelEXT</code> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <code>vkCmdEndDebugUtilsLabelEXT</code>"
},
{
"vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter",
},
{
"vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01492",
- "text": " <code>object</code> <strong class=\"purple\">must</strong> be a Vulkan object of the type associated with <code>objectType</code> as defined in <a href=\"#debug-report-object-types\">VkDebugReportObjectTypeEXT and Vulkan Handle Relationship</a>."
+ "text": " <code>object</code> <strong class=\"purple\">must</strong> be a Vulkan object of the type associated with <code>objectType</code> as defined in <a href=\"#debug-report-object-types\"><a href=\"#VkDebugReportObjectTypeEXT\">VkDebugReportObjectTypeEXT</a> and Vulkan Handle Relationship</a>"
},
{
"vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-sType-sType",
},
{
"vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01495",
- "text": " <code>object</code> <strong class=\"purple\">must</strong> be a Vulkan object of the type associated with <code>objectType</code> as defined in <a href=\"#debug-report-object-types\">VkDebugReportObjectTypeEXT and Vulkan Handle Relationship</a>."
+ "text": " <code>object</code> <strong class=\"purple\">must</strong> be a Vulkan object of the type associated with <code>objectType</code> as defined in <a href=\"#debug-report-object-types\"><a href=\"#VkDebugReportObjectTypeEXT\">VkDebugReportObjectTypeEXT</a> and Vulkan Handle Relationship</a>"
},
{
"vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-sType-sType",
},
{
"vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240",
- "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> be an outstanding <a href=\"#vkCmdDebugMarkerBeginEXT\">vkCmdDebugMarkerBeginEXT</a> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <a href=\"#vkCmdDebugMarkerEndEXT\">vkCmdDebugMarkerEndEXT</a>."
+ "text": " If <code>commandBuffer</code> is a secondary command buffer, there <strong class=\"purple\">must</strong> be an outstanding <a href=\"#vkCmdDebugMarkerBeginEXT\">vkCmdDebugMarkerBeginEXT</a> command recorded to <code>commandBuffer</code> that has not previously been ended by a call to <a href=\"#vkCmdDebugMarkerEndEXT\">vkCmdDebugMarkerEndEXT</a>"
},
{
"vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter",
},
{
"vuid": "VUID-vkDebugReportMessageEXT-objectType-01498",
- "text": " If <code>objectType</code> is not <code>VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT</code> and <code>object</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>object</code> <strong class=\"purple\">must</strong> be a Vulkan object of the corresponding type associated with <code>objectType</code> as defined in <a href=\"#debug-report-object-types\">VkDebugReportObjectTypeEXT and Vulkan Handle Relationship</a>."
+ "text": " If <code>objectType</code> is not <code>VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT</code> and <code>object</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>object</code> <strong class=\"purple\">must</strong> be a Vulkan object of the corresponding type associated with <code>objectType</code> as defined in <a href=\"#debug-report-object-types\"><a href=\"#VkDebugReportObjectTypeEXT\">VkDebugReportObjectTypeEXT</a> and Vulkan Handle Relationship</a>"
},
{
"vuid": "VUID-vkDebugReportMessageEXT-instance-parameter",
projects / platform / upstream / Vulkan-Headers.git / commitdiff