}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAabbPositionsKHR *>( this );
}
- operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAabbPositionsKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &, float const &, float const &, float const &, float const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( minX, minY, minZ, maxX, maxY, maxZ );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AabbPositionsKHR const & ) const = default;
#else
bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) &&
- ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"AabbPositionsKHR is not nothrow_move_constructible!" );
using AabbPositionsNV = AabbPositionsKHR;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minX );
- VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minY );
- VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minZ );
- VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxX );
- VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxY );
- VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxZ );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union DeviceOrHostAddressConstKHR
{
using NativeType = VkDeviceOrHostAddressConstKHR;
VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress;
const void * hostAddress;
#else
- VkDeviceAddress deviceAddress;
- const void * hostAddress;
+ VkDeviceAddress deviceAddress;
+ const void * hostAddress;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
}
- operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::IndexType const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR *>( this );
}
- operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, data, stride );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR *>( this );
}
- operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, arrayOfPointers, data );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureGeometryKHR *>( this );
}
- operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureGeometryKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::GeometryTypeKHR const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const &,
+ VULKAN_HPP_NAMESPACE::GeometryFlagsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, geometryType, geometry, flags );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryKHR;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress;
void * hostAddress;
#else
- VkDeviceAddress deviceAddress;
- void * hostAddress;
+ VkDeviceAddress deviceAddress;
+ void * hostAddress;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( this );
}
- operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR const &,
+ VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::BuildAccelerationStructureModeKHR const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const &,
+ const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const * const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ type,
+ flags,
+ mode,
+ srcAccelerationStructure,
+ dstAccelerationStructure,
+ geometryCount,
+ pGeometries,
+ ppGeometries,
+ scratchData );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR *>( this );
}
- operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default;
#else
bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) &&
- ( firstVertex == rhs.firstVertex ) && ( transformOffset == rhs.transformOffset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>::value,
"AccelerationStructureBuildRangeInfoKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const &
- accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.firstVertex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.transformOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureBuildSizesInfoKHR
{
using NativeType = VkAccelerationStructureBuildSizesInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR *>( this );
}
- operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default;
#else
bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( accelerationStructureSize == rhs.accelerationStructureSize ) &&
- ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureBuildSizesInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const &
- accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureBuildSizesInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureBuildSizesInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureCreateInfoKHR
{
using NativeType = VkAccelerationStructureCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( this );
}
- operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR const &,
+ VULKAN_HPP_NAMESPACE::DeviceAddress const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default;
#else
bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) &&
- ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ) && ( type == rhs.type ) &&
- ( deviceAddress == rhs.deviceAddress );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &
- accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR, seed, accelerationStructureCreateInfoKHR.createFlags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, accelerationStructureCreateInfoKHR.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.size );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR, seed, accelerationStructureCreateInfoKHR.type );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceAddress, seed, accelerationStructureCreateInfoKHR.deviceAddress );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GeometryTrianglesNV
{
using NativeType = VkGeometryTrianglesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeometryTrianglesNV *>( this );
}
- operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGeometryTrianglesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::IndexType const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ vertexData,
+ vertexOffset,
+ vertexCount,
+ vertexStride,
+ vertexFormat,
+ indexData,
+ indexOffset,
+ indexCount,
+ indexType,
+ transformData,
+ transformOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GeometryTrianglesNV const & ) const = default;
#else
bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GeometryTrianglesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryTrianglesNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryTrianglesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.vertexData );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.vertexCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexStride );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, geometryTrianglesNV.vertexFormat );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.indexData );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.indexOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.indexCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, geometryTrianglesNV.indexType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.transformData );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.transformOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GeometryAABBNV
{
using NativeType = VkGeometryAABBNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeometryAABBNV *>( this );
}
- operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGeometryAABBNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, aabbData, numAABBs, stride, offset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GeometryAABBNV const & ) const = default;
#else
bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) &&
- ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && ( offset == rhs.offset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GeometryAABBNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryAABBNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryAABBNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryAABBNV.aabbData );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.numAABBs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.stride );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryAABBNV.offset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GeometryDataNV
{
using NativeType = VkGeometryDataNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeometryDataNV *>( this );
}
- operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGeometryDataNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const &, VULKAN_HPP_NAMESPACE::GeometryAABBNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( triangles, aabbs );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GeometryDataNV const & ) const = default;
#else
bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::GeometryDataNV>::value,
"GeometryDataNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV, seed, geometryDataNV.triangles );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryAABBNV, seed, geometryDataNV.aabbs );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GeometryNV
{
using NativeType = VkGeometryNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeometryNV *>( this );
}
- operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGeometryNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::GeometryTypeKHR const &,
+ VULKAN_HPP_NAMESPACE::GeometryDataNV const &,
+ VULKAN_HPP_NAMESPACE::GeometryFlagsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, geometryType, geometry, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GeometryNV const & ) const = default;
#else
bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) &&
- ( geometry == rhs.geometry ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GeometryNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeometryNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTypeKHR, seed, geometryNV.geometryType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryDataNV, seed, geometryNV.geometry );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryFlagsKHR, seed, geometryNV.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureInfoNV
{
using NativeType = VkAccelerationStructureInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureInfoNV *>( this );
}
- operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV const &,
+ VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::GeometryNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureInfoNV const & ) const = default;
#else
bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) &&
- ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) &&
- ( pGeometries == rhs.pGeometries );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV, seed, accelerationStructureInfoNV.type );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV, seed, accelerationStructureInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.instanceCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.geometryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GeometryNV *, seed, accelerationStructureInfoNV.pGeometries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureCreateInfoNV
{
using NativeType = VkAccelerationStructureCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( this );
}
- operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, compactedSize, info );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default;
#else
bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) &&
- ( info == rhs.info );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &
- accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoNV.compactedSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV, seed, accelerationStructureCreateInfoNV.info );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureDeviceAddressInfoKHR
{
using NativeType = VkAccelerationStructureDeviceAddressInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( this );
}
- operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, accelerationStructure );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default;
#else
bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureDeviceAddressInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const &
- accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureDeviceAddressInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureDeviceAddressInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR,
- seed,
- accelerationStructureDeviceAddressInfoKHR.accelerationStructure );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureGeometryMotionTrianglesDataNV
{
using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
}
- operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, vertexData );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTransformMatrixKHR *>( this );
}
- operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTransformMatrixKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper2D<float, 3, 4> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( matrix );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TransformMatrixKHR const & ) const = default;
#else
bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( matrix == rhs.matrix );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"TransformMatrixKHR is not nothrow_move_constructible!" );
using TransformMatrixNV = TransformMatrixKHR;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- for ( size_t i = 0; i < 3; ++i )
- {
- for ( size_t j = 0; j < 4; ++j )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, transformMatrixKHR.matrix[i][j] );
- }
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureInstanceKHR
{
using NativeType = VkAccelerationStructureInstanceKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureInstanceKHR *>( this );
}
- operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureInstanceKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VkGeometryInstanceFlagsKHR const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( transform,
+ instanceCustomIndex,
+ mask,
+ instanceShaderBindingTableRecordOffset,
+ flags,
+ accelerationStructureReference );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default;
#else
bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) &&
- ( mask == rhs.mask ) &&
- ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
- ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"AccelerationStructureInstanceKHR is not nothrow_move_constructible!" );
using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureInstanceKHR.transform );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceCustomIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.mask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset );
- VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureInstanceKHR.flags );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureInstanceKHR.accelerationStructureReference );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureMatrixMotionInstanceNV
{
using NativeType = VkAccelerationStructureMatrixMotionInstanceNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureMatrixMotionInstanceNV *>( this );
}
- operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
+ VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VkGeometryInstanceFlagsKHR const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( transformT0,
+ transformT1,
+ instanceCustomIndex,
+ mask,
+ instanceShaderBindingTableRecordOffset,
+ flags,
+ accelerationStructureReference );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default;
#else
bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) &&
- ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
- ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
- ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>::value,
"AccelerationStructureMatrixMotionInstanceNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const &
- accelerationStructureMatrixMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT0 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT1 );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.mask );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset );
- VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureMatrixMotionInstanceNV.flags );
- VULKAN_HPP_HASH_COMBINE(
- uint64_t, seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureMemoryRequirementsInfoNV
{
using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
}
- operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, type, accelerationStructure );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default;
#else
bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
- ( accelerationStructure == rhs.accelerationStructure );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureMemoryRequirementsInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const &
- accelerationStructureMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMemoryRequirementsInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMemoryRequirementsInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV,
- seed,
- accelerationStructureMemoryRequirementsInfoNV.type );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV,
- seed,
- accelerationStructureMemoryRequirementsInfoNV.accelerationStructure );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureMotionInfoNV
{
using NativeType = VkAccelerationStructureMotionInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureMotionInfoNV *>( this );
}
- operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureMotionInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxInstances, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default;
#else
bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) &&
- ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureMotionInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const &
- accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMotionInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMotionInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMotionInfoNV.maxInstances );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV, seed, accelerationStructureMotionInfoNV.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SRTDataNV
{
using NativeType = VkSRTDataNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSRTDataNV *>( this );
}
- operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSRTDataNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SRTDataNV const & ) const = default;
#else
bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) &&
- ( c == rhs.c ) && ( pvy == rhs.pvy ) && ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) &&
- ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && ( ty == rhs.ty ) &&
- ( tz == rhs.tz );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SRTDataNV>::value,
"SRTDataNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sx );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.a );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.b );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvx );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sy );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.c );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvy );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sz );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvz );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qx );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qy );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qz );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qw );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tx );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.ty );
- VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tz );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AccelerationStructureSRTMotionInstanceNV
{
using NativeType = VkAccelerationStructureSRTMotionInstanceNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureSRTMotionInstanceNV *>( this );
}
- operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::SRTDataNV const &,
+ VULKAN_HPP_NAMESPACE::SRTDataNV const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VkGeometryInstanceFlagsKHR const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( transformT0,
+ transformT1,
+ instanceCustomIndex,
+ mask,
+ instanceShaderBindingTableRecordOffset,
+ flags,
+ accelerationStructureReference );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default;
#else
bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) &&
- ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
- ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
- ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>::value,
"AccelerationStructureSRTMotionInstanceNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const &
- accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT0 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT1 );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.mask );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset );
- VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureSRTMotionInstanceNV.flags );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union AccelerationStructureMotionInstanceDataNV
{
using NativeType = VkAccelerationStructureMotionInstanceDataNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureMotionInstanceNV *>( this );
}
- operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureMotionInstanceNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( type, flags, data );
+ }
+
public:
VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type =
VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV::eStatic;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( this );
}
- operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureVersionInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const uint8_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pVersionData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default;
#else
bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AccelerationStructureVersionInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const &
- accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureVersionInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureVersionInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, accelerationStructureVersionInfoKHR.pVersionData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AcquireNextImageInfoKHR
{
using NativeType = VkAcquireNextImageInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAcquireNextImageInfoKHR *>( this );
}
- operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAcquireNextImageInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SwapchainKHR const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::Fence const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AcquireNextImageInfoKHR const & ) const = default;
#else
bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) &&
- ( timeout == rhs.timeout ) && ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) &&
- ( deviceMask == rhs.deviceMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AcquireNextImageInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireNextImageInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireNextImageInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, acquireNextImageInfoKHR.swapchain );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireNextImageInfoKHR.timeout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, acquireNextImageInfoKHR.semaphore );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, acquireNextImageInfoKHR.fence );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, acquireNextImageInfoKHR.deviceMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AcquireProfilingLockInfoKHR
{
using NativeType = VkAcquireProfilingLockInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( this );
}
- operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAcquireProfilingLockInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, timeout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default;
#else
bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = AcquireProfilingLockInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireProfilingLockInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireProfilingLockInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR, seed, acquireProfilingLockInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireProfilingLockInfoKHR.timeout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AllocationCallbacks
{
using NativeType = VkAllocationCallbacks;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAllocationCallbacks *>( this );
}
- operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAllocationCallbacks *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<void * const &,
+ PFN_vkAllocationFunction const &,
+ PFN_vkReallocationFunction const &,
+ PFN_vkFreeFunction const &,
+ PFN_vkInternalAllocationNotification const &,
+ PFN_vkInternalFreeNotification const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AllocationCallbacks const & ) const = default;
#else
bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) &&
- ( pfnReallocation == rhs.pfnReallocation ) && ( pfnFree == rhs.pfnFree ) &&
- ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AllocationCallbacks>::value,
"AllocationCallbacks is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( void *, seed, allocationCallbacks.pUserData );
- VULKAN_HPP_HASH_COMBINE( PFN_vkAllocationFunction, seed, allocationCallbacks.pfnAllocation );
- VULKAN_HPP_HASH_COMBINE( PFN_vkReallocationFunction, seed, allocationCallbacks.pfnReallocation );
- VULKAN_HPP_HASH_COMBINE( PFN_vkFreeFunction, seed, allocationCallbacks.pfnFree );
- VULKAN_HPP_HASH_COMBINE( PFN_vkInternalAllocationNotification, seed, allocationCallbacks.pfnInternalAllocation );
- VULKAN_HPP_HASH_COMBINE( PFN_vkInternalFreeNotification, seed, allocationCallbacks.pfnInternalFree );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ComponentMapping
{
using NativeType = VkComponentMapping;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkComponentMapping *>( this );
}
- operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkComponentMapping *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
+ VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
+ VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
+ VULKAN_HPP_NAMESPACE::ComponentSwizzle const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( r, g, b, a );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ComponentMapping const & ) const = default;
#else
bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ComponentMapping>::value,
"ComponentMapping is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.r );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.g );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.b );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.a );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
struct AndroidHardwareBufferFormatProperties2ANDROID
{
return *this;
}
- operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
}
- operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ format,
+ externalFormat,
+ formatFeatures,
+ samplerYcbcrConversionComponents,
+ suggestedYcbcrModel,
+ suggestedYcbcrRange,
+ suggestedXChromaOffset,
+ suggestedYChromaOffset );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default;
# else
bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = AndroidHardwareBufferFormatProperties2ANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const &
- androidHardwareBufferFormatProperties2ANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatProperties2ANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatProperties2ANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatProperties2ANDROID.format );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR,
- seed,
- androidHardwareBufferFormatProperties2ANDROID.formatFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
- seed,
- androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion,
- seed,
- androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrRange,
- seed,
- androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation,
- seed,
- androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation,
- seed,
- androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
return *this;
}
- operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
}
- operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ format,
+ externalFormat,
+ formatFeatures,
+ samplerYcbcrConversionComponents,
+ suggestedYcbcrModel,
+ suggestedYcbcrRange,
+ suggestedXChromaOffset,
+ suggestedYChromaOffset );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default;
# else
bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = AndroidHardwareBufferFormatPropertiesANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const &
- androidHardwareBufferFormatPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatPropertiesANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatPropertiesANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatPropertiesANDROID.format );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
- seed,
- androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion,
- seed,
- androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
return *this;
}
- operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID *>( this );
}
- operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, allocationSize, memoryTypeBits );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default;
# else
bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) &&
- ( memoryTypeBits == rhs.memoryTypeBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = AndroidHardwareBufferPropertiesANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const &
- androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferPropertiesANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferPropertiesANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, androidHardwareBufferPropertiesANDROID.allocationSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
return *this;
}
- operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>( this );
}
- operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, androidHardwareBufferUsage );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default;
# else
bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = AndroidHardwareBufferUsageANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const &
- androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferUsageANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferUsageANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( this );
}
- operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR const &,
+ struct ANativeWindow * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, window );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default;
# else
bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = AndroidSurfaceCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidSurfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, androidSurfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR, seed, androidSurfaceCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( struct ANativeWindow *, seed, androidSurfaceCreateInfoKHR.window );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
struct ApplicationInfo
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkApplicationInfo *>( this );
}
- operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkApplicationInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const char * const &,
+ uint32_t const &,
+ const char * const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ApplicationInfo const & ) const = default;
#else
bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pApplicationName == rhs.pApplicationName ) &&
- ( applicationVersion == rhs.applicationVersion ) && ( pEngineName == rhs.pEngineName ) &&
- ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ApplicationInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, applicationInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, applicationInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pApplicationName );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.applicationVersion );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pEngineName );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.engineVersion );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.apiVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentDescription
{
using NativeType = VkAttachmentDescription;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentDescription *>( this );
}
- operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentDescription *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentDescription const & ) const = default;
#else
bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) &&
- ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) &&
- ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) &&
- ( finalLayout == rhs.finalLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentDescription>::value,
"AttachmentDescription is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription.samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.loadOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.storeOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.stencilLoadOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.stencilStoreOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.initialLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.finalLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentDescription2
{
using NativeType = VkAttachmentDescription2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentDescription2 *>( this );
}
- operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentDescription2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ format,
+ samples,
+ loadOp,
+ storeOp,
+ stencilLoadOp,
+ stencilStoreOp,
+ initialLayout,
+ finalLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentDescription2 const & ) const = default;
#else
bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using AttachmentDescription2KHR = AttachmentDescription2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescription2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentDescription2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription2.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription2.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription2.samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.loadOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.storeOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.stencilLoadOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.stencilStoreOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.initialLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.finalLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentDescriptionStencilLayout
{
using NativeType = VkAttachmentDescriptionStencilLayout;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentDescriptionStencilLayout *>( this );
}
- operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentDescriptionStencilLayout *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default;
#else
bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) &&
- ( stencilFinalLayout == rhs.stencilFinalLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const &
- attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescriptionStencilLayout.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentDescriptionStencilLayout.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilInitialLayout );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilFinalLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentReference
{
using NativeType = VkAttachmentReference;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentReference *>( this );
}
- operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentReference *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( attachment, layout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentReference const & ) const = default;
#else
bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( attachment == rhs.attachment ) && ( layout == rhs.layout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentReference>::value,
"AttachmentReference is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference.attachment );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference.layout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentReference2
{
using NativeType = VkAttachmentReference2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentReference2 *>( this );
}
- operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentReference2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ImageAspectFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, attachment, layout, aspectMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentReference2 const & ) const = default;
#else
bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) &&
- ( layout == rhs.layout ) && ( aspectMask == rhs.aspectMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using AttachmentReference2KHR = AttachmentReference2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReference2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentReference2.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference2.attachment );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference2.layout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, attachmentReference2.aspectMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentReferenceStencilLayout
{
using NativeType = VkAttachmentReferenceStencilLayout;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentReferenceStencilLayout *>( this );
}
- operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentReferenceStencilLayout *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stencilLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default;
#else
bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReferenceStencilLayout.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentReferenceStencilLayout.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReferenceStencilLayout.stencilLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentSampleCountInfoAMD
{
using NativeType = VkAttachmentSampleCountInfoAMD;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>( this );
}
- operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentSampleCountInfoAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SampleCountFlagBits * const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default;
#else
bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
- ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) &&
- ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentSampleCountInfoAMD.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentSampleCountInfoAMD.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleCountInfoAMD.colorAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SampleCountFlagBits *, seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct Extent2D
{
using NativeType = VkExtent2D;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExtent2D *>( this );
}
- operator VkExtent2D &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExtent2D &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExtent2D *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( width, height );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Extent2D const & ) const = default;
#else
bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( width == rhs.width ) && ( height == rhs.height );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Extent2D>::value,
"Extent2D is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Extent2D>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.width );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.height );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SampleLocationEXT
{
using NativeType = VkSampleLocationEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSampleLocationEXT *>( this );
}
- operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSampleLocationEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SampleLocationEXT const & ) const = default;
#else
bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SampleLocationEXT>::value,
"SampleLocationEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.x );
- VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.y );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SampleLocationsInfoEXT
{
using NativeType = VkSampleLocationsInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSampleLocationsInfoEXT *>( this );
}
- operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSampleLocationsInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SampleLocationEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SampleLocationsInfoEXT const & ) const = default;
#else
bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) &&
- ( sampleLocationGridSize == rhs.sampleLocationGridSize ) &&
- ( sampleLocationsCount == rhs.sampleLocationsCount ) && ( pSampleLocations == rhs.pSampleLocations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SampleLocationsInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sampleLocationsInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, sampleLocationsInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, sampleLocationsInfoEXT.sampleLocationsPerPixel );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, sampleLocationsInfoEXT.sampleLocationGridSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sampleLocationsInfoEXT.sampleLocationsCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SampleLocationEXT *, seed, sampleLocationsInfoEXT.pSampleLocations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct AttachmentSampleLocationsEXT
{
using NativeType = VkAttachmentSampleLocationsEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAttachmentSampleLocationsEXT *>( this );
}
- operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAttachmentSampleLocationsEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( attachmentIndex, sampleLocationsInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default;
#else
bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>::value,
"AttachmentSampleLocationsEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleLocationsEXT.attachmentIndex );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, attachmentSampleLocationsEXT.sampleLocationsInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BaseInStructure
{
using NativeType = VkBaseInStructure;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBaseInStructure *>( this );
}
- operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBaseInStructure *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const struct VULKAN_HPP_NAMESPACE::BaseInStructure * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BaseInStructure const & ) const = default;
#else
bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BaseInStructure>::value,
"BaseInStructure is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseInStructure.sType );
- VULKAN_HPP_HASH_COMBINE( const struct VULKAN_HPP_NAMESPACE::BaseInStructure *, seed, baseInStructure.pNext );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BaseOutStructure
{
using NativeType = VkBaseOutStructure;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBaseOutStructure *>( this );
}
- operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBaseOutStructure *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, struct VULKAN_HPP_NAMESPACE::BaseOutStructure * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BaseOutStructure const & ) const = default;
#else
bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BaseOutStructure>::value,
"BaseOutStructure is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseOutStructure.sType );
- VULKAN_HPP_HASH_COMBINE( struct VULKAN_HPP_NAMESPACE::BaseOutStructure *, seed, baseOutStructure.pNext );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindAccelerationStructureMemoryInfoNV
{
using NativeType = VkBindAccelerationStructureMemoryInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( this );
}
- operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default;
#else
bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) &&
- ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
- ( pDeviceIndices == rhs.pDeviceIndices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BindAccelerationStructureMemoryInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const &
- bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindAccelerationStructureMemoryInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindAccelerationStructureMemoryInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV,
- seed,
- bindAccelerationStructureMemoryInfoNV.accelerationStructure );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindAccelerationStructureMemoryInfoNV.memory );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindAccelerationStructureMemoryInfoNV.memoryOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindBufferMemoryDeviceGroupInfo
{
using NativeType = VkBindBufferMemoryDeviceGroupInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>( this );
}
- operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default;
#else
bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
- ( pDeviceIndices == rhs.pDeviceIndices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryDeviceGroupInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryDeviceGroupInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindBufferMemoryInfo
{
using NativeType = VkBindBufferMemoryInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindBufferMemoryInfo *>( this );
}
- operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindBufferMemoryInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, buffer, memory, memoryOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindBufferMemoryInfo const & ) const = default;
#else
bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) &&
- ( memoryOffset == rhs.memoryOffset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bindBufferMemoryInfo.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindBufferMemoryInfo.memory );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindBufferMemoryInfo.memoryOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct Offset2D
{
using NativeType = VkOffset2D;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkOffset2D *>( this );
}
- operator VkOffset2D &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkOffset2D &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkOffset2D *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<int32_t const &, int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Offset2D const & ) const = default;
#else
bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Offset2D>::value,
"Offset2D is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Offset2D>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.x );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.y );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct Rect2D
{
using NativeType = VkRect2D;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRect2D *>( this );
}
- operator VkRect2D &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRect2D &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRect2D *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Offset2D const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( offset, extent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Rect2D const & ) const = default;
#else
bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( offset == rhs.offset ) && ( extent == rhs.extent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Rect2D>::value,
"Rect2D is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Rect2D>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rect2D.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rect2D.extent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindImageMemoryDeviceGroupInfo
{
using NativeType = VkBindImageMemoryDeviceGroupInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>( this );
}
- operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default;
#else
bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
- ( pDeviceIndices == rhs.pDeviceIndices ) &&
- ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) &&
- ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryDeviceGroupInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryDeviceGroupInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Rect2D *, seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindImageMemoryInfo
{
using NativeType = VkBindImageMemoryInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindImageMemoryInfo *>( this );
}
- operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindImageMemoryInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, image, memory, memoryOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindImageMemoryInfo const & ) const = default;
#else
bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) &&
- ( memoryOffset == rhs.memoryOffset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BindImageMemoryInfoKHR = BindImageMemoryInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, bindImageMemoryInfo.image );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindImageMemoryInfo.memory );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindImageMemoryInfo.memoryOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindImageMemorySwapchainInfoKHR
{
using NativeType = VkBindImageMemorySwapchainInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>( this );
}
- operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SwapchainKHR const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchain, imageIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default;
#else
bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) &&
- ( imageIndex == rhs.imageIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BindImageMemorySwapchainInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemorySwapchainInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemorySwapchainInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, bindImageMemorySwapchainInfoKHR.swapchain );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemorySwapchainInfoKHR.imageIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindImagePlaneMemoryInfo
{
using NativeType = VkBindImagePlaneMemoryInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindImagePlaneMemoryInfo *>( this );
}
- operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindImagePlaneMemoryInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, planeAspect );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default;
#else
bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImagePlaneMemoryInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImagePlaneMemoryInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, bindImagePlaneMemoryInfo.planeAspect );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindIndexBufferIndirectCommandNV
{
using NativeType = VkBindIndexBufferIndirectCommandNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindIndexBufferIndirectCommandNV *>( this );
}
- operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &, uint32_t const &, VULKAN_HPP_NAMESPACE::IndexType const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( bufferAddress, size, indexType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default;
#else
bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>::value,
"BindIndexBufferIndirectCommandNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindIndexBufferIndirectCommandNV.bufferAddress );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindIndexBufferIndirectCommandNV.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, bindIndexBufferIndirectCommandNV.indexType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindShaderGroupIndirectCommandNV
{
using NativeType = VkBindShaderGroupIndirectCommandNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindShaderGroupIndirectCommandNV *>( this );
}
- operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( groupIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default;
#else
bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( groupIndex == rhs.groupIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>::value,
"BindShaderGroupIndirectCommandNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindShaderGroupIndirectCommandNV.groupIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseMemoryBind
{
using NativeType = VkSparseMemoryBind;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseMemoryBind *>( this );
}
- operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseMemoryBind *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( resourceOffset, size, memory, memoryOffset, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseMemoryBind const & ) const = default;
#else
bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) &&
- ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseMemoryBind>::value,
"SparseMemoryBind is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.resourceOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseMemoryBind.memory );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.memoryOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseMemoryBind.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseBufferMemoryBindInfo
{
using NativeType = VkSparseBufferMemoryBindInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseBufferMemoryBindInfo *>( this );
}
- operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseBufferMemoryBindInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SparseMemoryBind * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( buffer, bindCount, pBinds );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default;
#else
bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>::value,
"SparseBufferMemoryBindInfo is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, sparseBufferMemoryBindInfo.buffer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseBufferMemoryBindInfo.bindCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseBufferMemoryBindInfo.pBinds );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageOpaqueMemoryBindInfo
{
using NativeType = VkSparseImageOpaqueMemoryBindInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo *>( this );
}
- operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Image const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SparseMemoryBind * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( image, bindCount, pBinds );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default;
#else
bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>::value,
"SparseImageOpaqueMemoryBindInfo is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageOpaqueMemoryBindInfo.image );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageOpaqueMemoryBindInfo.bindCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseImageOpaqueMemoryBindInfo.pBinds );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageSubresource
{
using NativeType = VkImageSubresource;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageSubresource *>( this );
}
- operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageSubresource *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( aspectMask, mipLevel, arrayLayer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageSubresource const & ) const = default;
#else
bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresource>::value,
"ImageSubresource is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresource.aspectMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.mipLevel );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.arrayLayer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct Offset3D
{
using NativeType = VkOffset3D;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkOffset3D *>( this );
}
- operator VkOffset3D &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkOffset3D &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkOffset3D *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<int32_t const &, int32_t const &, int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y, z );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Offset3D const & ) const = default;
#else
bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Offset3D>::value,
"Offset3D is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Offset3D>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.x );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.y );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.z );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct Extent3D
{
using NativeType = VkExtent3D;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExtent3D *>( this );
}
- operator VkExtent3D &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExtent3D &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExtent3D *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( width, height, depth );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Extent3D const & ) const = default;
#else
bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Extent3D>::value,
"Extent3D is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Extent3D>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.width );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.height );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.depth );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageMemoryBind
{
using NativeType = VkSparseImageMemoryBind;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageMemoryBind *>( this );
}
- operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageMemoryBind *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresource const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( subresource, offset, extent, memory, memoryOffset, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageMemoryBind const & ) const = default;
#else
bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) &&
- ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>::value,
"SparseImageMemoryBind is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresource, seed, sparseImageMemoryBind.subresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, sparseImageMemoryBind.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageMemoryBind.extent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseImageMemoryBind.memory );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryBind.memoryOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseImageMemoryBind.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageMemoryBindInfo
{
using NativeType = VkSparseImageMemoryBindInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageMemoryBindInfo *>( this );
}
- operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageMemoryBindInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Image const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( image, bindCount, pBinds );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageMemoryBindInfo const & ) const = default;
#else
bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>::value,
"SparseImageMemoryBindInfo is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageMemoryBindInfo.image );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryBindInfo.bindCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind *, seed, sparseImageMemoryBindInfo.pBinds );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindSparseInfo
{
using NativeType = VkBindSparseInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindSparseInfo *>( this );
}
- operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindSparseInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Semaphore * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ waitSemaphoreCount,
+ pWaitSemaphores,
+ bufferBindCount,
+ pBufferBinds,
+ imageOpaqueBindCount,
+ pImageOpaqueBinds,
+ imageBindCount,
+ pImageBinds,
+ signalSemaphoreCount,
+ pSignalSemaphores );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindSparseInfo const & ) const = default;
#else
bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
- ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) &&
- ( pBufferBinds == rhs.pBufferBinds ) && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) &&
- ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && ( imageBindCount == rhs.imageBindCount ) &&
- ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
- ( pSignalSemaphores == rhs.pSignalSemaphores );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BindSparseInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindSparseInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bindSparseInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.waitSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pWaitSemaphores );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.bufferBindCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo *, seed, bindSparseInfo.pBufferBinds );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageOpaqueBindCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo *, seed, bindSparseInfo.pImageOpaqueBinds );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageBindCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo *, seed, bindSparseInfo.pImageBinds );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.signalSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pSignalSemaphores );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BindVertexBufferIndirectCommandNV
{
using NativeType = VkBindVertexBufferIndirectCommandNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBindVertexBufferIndirectCommandNV *>( this );
}
- operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( bufferAddress, size, stride );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default;
#else
bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>::value,
"BindVertexBufferIndirectCommandNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const &
- bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindVertexBufferIndirectCommandNV.bufferAddress );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.size );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.stride );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageSubresourceLayers
{
using NativeType = VkImageSubresourceLayers;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageSubresourceLayers *>( this );
}
- operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageSubresourceLayers *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageSubresourceLayers const & ) const = default;
#else
bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) &&
- ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>::value,
"ImageSubresourceLayers is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceLayers.aspectMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.mipLevel );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.baseArrayLayer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.layerCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageBlit2KHR
{
using NativeType = VkImageBlit2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageBlit2KHR *>( this );
}
- operator VkImageBlit2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageBlit2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageBlit2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageBlit2KHR const & ) const = default;
#else
bool operator==( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
- ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) &&
- ( dstOffsets == rhs.dstOffsets );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageBlit2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageBlit2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2KHR const & imageBlit2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageBlit2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageBlit2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.srcSubresource );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.srcOffsets[i] );
- }
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.dstSubresource );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.dstOffsets[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BlitImageInfo2KHR
{
using NativeType = VkBlitImageInfo2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBlitImageInfo2KHR *>( this );
}
- operator VkBlitImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBlitImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBlitImageInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageBlit2KHR * const &,
+ VULKAN_HPP_NAMESPACE::Filter const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BlitImageInfo2KHR const & ) const = default;
#else
bool operator==( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
- ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
- ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
- ( pRegions == rhs.pRegions ) && ( filter == rhs.filter );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BlitImageInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR const & blitImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, blitImageInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, blitImageInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.srcImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.srcImageLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.dstImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.dstImageLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, blitImageInfo2KHR.regionCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageBlit2KHR *, seed, blitImageInfo2KHR.pRegions );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, blitImageInfo2KHR.filter );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_FUCHSIA )
struct BufferCollectionBufferCreateInfoFUCHSIA
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
}
- operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, collection, index );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default;
# else
bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
- ( index == rhs.index );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = BufferCollectionBufferCreateInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const &
- bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionBufferCreateInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionBufferCreateInfoFUCHSIA.collection );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionBufferCreateInfoFUCHSIA.index );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
}
- operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ minBufferCount,
+ maxBufferCount,
+ minBufferCountForCamping,
+ minBufferCountForDedicatedSlack,
+ minBufferCountForSharedSlack );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default;
# else
bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) &&
- ( maxBufferCount == rhs.maxBufferCount ) && ( minBufferCountForCamping == rhs.minBufferCountForCamping ) &&
- ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) &&
- ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = BufferCollectionConstraintsInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &
- bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionConstraintsInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionConstraintsInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( this );
}
- operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, zx_handle_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, collectionToken );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCollectionCreateInfoFUCHSIA const & ) const = default;
# else
bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = BufferCollectionCreateInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &
- bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionCreateInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionCreateInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, bufferCollectionCreateInfoFUCHSIA.collectionToken );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
}
- operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, collection, index );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default;
# else
bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
- ( index == rhs.index );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = BufferCollectionImageCreateInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const &
- bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionImageCreateInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionImageCreateInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionImageCreateInfoFUCHSIA.collection );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionImageCreateInfoFUCHSIA.index );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSysmemColorSpaceFUCHSIA *>( this );
}
- operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSysmemColorSpaceFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, colorSpace );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default;
# else
bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = SysmemColorSpaceFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sysmemColorSpaceFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, sysmemColorSpaceFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sysmemColorSpaceFUCHSIA.colorSpace );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA *>( this );
}
- operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const &,
+ VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ memoryTypeBits,
+ bufferCount,
+ createInfoIndex,
+ sysmemPixelFormat,
+ formatFeatures,
+ sysmemColorSpaceIndex,
+ samplerYcbcrConversionComponents,
+ suggestedYcbcrModel,
+ suggestedYcbcrRange,
+ suggestedXChromaOffset,
+ suggestedYChromaOffset );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default;
# else
bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) &&
- ( bufferCount == rhs.bufferCount ) && ( createInfoIndex == rhs.createInfoIndex ) &&
- ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
- ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) &&
- ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
- ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
- ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
- ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = BufferCollectionPropertiesFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const &
- bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionPropertiesFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, bufferCollectionPropertiesFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.bufferCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferCollectionPropertiesFUCHSIA.formatFeatures );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA, seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping,
- seed,
- bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct BufferCreateInfo
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCreateInfo *>( this );
}
- operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::BufferUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::SharingMode const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCreateInfo const & ) const = default;
#else
bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) &&
- ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) &&
- ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
- ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, bufferCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCreateInfo.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, bufferCreateInfo.usage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, bufferCreateInfo.sharingMode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCreateInfo.queueFamilyIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bufferCreateInfo.pQueueFamilyIndices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_FUCHSIA )
struct BufferConstraintsInfoFUCHSIA
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( this );
}
- operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferConstraintsInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferCreateInfo const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default;
# else
bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) &&
- ( requiredFormatFeatures == rhs.requiredFormatFeatures ) &&
- ( bufferCollectionConstraints == rhs.bufferCollectionConstraints );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = BufferConstraintsInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferConstraintsInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferConstraintsInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateInfo, seed, bufferConstraintsInfoFUCHSIA.createInfo );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA,
- seed,
- bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct BufferCopy
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCopy *>( this );
}
- operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCopy *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( srcOffset, dstOffset, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCopy const & ) const = default;
#else
bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferCopy>::value,
"BufferCopy is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCopy>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.srcOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.dstOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferCopy2KHR
{
using NativeType = VkBufferCopy2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferCopy2KHR *>( this );
}
- operator VkBufferCopy2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferCopy2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferCopy2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcOffset, dstOffset, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferCopy2KHR const & ) const = default;
#else
bool operator==( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) &&
- ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferCopy2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferCopy2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2KHR const & bufferCopy2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCopy2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCopy2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.srcOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.dstOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferDeviceAddressCreateInfoEXT
{
using NativeType = VkBufferDeviceAddressCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>( this );
}
- operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceAddress const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceAddress );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default;
#else
bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferDeviceAddressCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bufferDeviceAddressCreateInfoEXT.deviceAddress );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferDeviceAddressInfo
{
using NativeType = VkBufferDeviceAddressInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferDeviceAddressInfo *>( this );
}
- operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferDeviceAddressInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, buffer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferDeviceAddressInfo const & ) const = default;
#else
bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferDeviceAddressInfo.buffer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferImageCopy
{
using NativeType = VkBufferImageCopy;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferImageCopy *>( this );
}
- operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferImageCopy *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferImageCopy const & ) const = default;
#else
bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) &&
- ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) &&
- ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferImageCopy>::value,
"BufferImageCopy is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy.bufferOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferRowLength );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferImageHeight );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy.imageSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy.imageOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy.imageExtent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferImageCopy2KHR
{
using NativeType = VkBufferImageCopy2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferImageCopy2KHR *>( this );
}
- operator VkBufferImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferImageCopy2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferImageCopy2KHR const & ) const = default;
#else
bool operator==( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) &&
- ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) &&
- ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) &&
- ( imageExtent == rhs.imageExtent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferImageCopy2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR const & bufferImageCopy2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferImageCopy2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferImageCopy2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy2KHR.bufferOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferRowLength );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferImageHeight );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy2KHR.imageSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy2KHR.imageOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy2KHR.imageExtent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferMemoryBarrier
{
using NativeType = VkBufferMemoryBarrier;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferMemoryBarrier *>( this );
}
- operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferMemoryBarrier *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferMemoryBarrier const & ) const = default;
#else
bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
- ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
- ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
- ( offset == rhs.offset ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferMemoryBarrier;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.dstAccessMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.srcQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.dstQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferMemoryBarrier2KHR
{
using NativeType = VkBufferMemoryBarrier2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferMemoryBarrier2KHR *>( this );
}
- operator VkBufferMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferMemoryBarrier2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ srcStageMask,
+ srcAccessMask,
+ dstStageMask,
+ dstAccessMask,
+ srcQueueFamilyIndex,
+ dstQueueFamilyIndex,
+ buffer,
+ offset,
+ size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferMemoryBarrier2KHR const & ) const = default;
#else
bool operator==( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
- ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
- ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
- ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
- ( offset == rhs.offset ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferMemoryBarrier2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR const & bufferMemoryBarrier2KHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.srcStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.dstStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.dstAccessMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.srcQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.dstQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier2KHR.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferMemoryRequirementsInfo2
{
using NativeType = VkBufferMemoryRequirementsInfo2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( this );
}
- operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, buffer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default;
#else
bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryRequirementsInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryRequirementsInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryRequirementsInfo2.buffer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferOpaqueCaptureAddressCreateInfo
{
using NativeType = VkBufferOpaqueCaptureAddressCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo *>( this );
}
- operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, opaqueCaptureAddress );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default;
#else
bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const &
- bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferOpaqueCaptureAddressCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferOpaqueCaptureAddressCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct BufferViewCreateInfo
{
using NativeType = VkBufferViewCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkBufferViewCreateInfo *>( this );
}
- operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkBufferViewCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferViewCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, buffer, format, offset, range );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferViewCreateInfo const & ) const = default;
#else
bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) &&
- ( format == rhs.format ) && ( offset == rhs.offset ) && ( range == rhs.range );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = BufferViewCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferViewCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferViewCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags, seed, bufferViewCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferViewCreateInfo.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, bufferViewCreateInfo.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.range );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CalibratedTimestampInfoEXT
{
using NativeType = VkCalibratedTimestampInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( this );
}
- operator VkCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCalibratedTimestampInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::TimeDomainEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, timeDomain );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CalibratedTimestampInfoEXT const & ) const = default;
#else
bool operator==( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CalibratedTimestampInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, calibratedTimestampInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, calibratedTimestampInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TimeDomainEXT, seed, calibratedTimestampInfoEXT.timeDomain );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CheckpointData2NV
{
using NativeType = VkCheckpointData2NV;
return *this;
}
- operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCheckpointData2NV *>( this );
}
- operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCheckpointData2NV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stage, pCheckpointMarker );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CheckpointData2NV const & ) const = default;
#else
bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) &&
- ( pCheckpointMarker == rhs.pCheckpointMarker );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CheckpointData2NV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointData2NV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, checkpointData2NV.stage );
- VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pCheckpointMarker );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CheckpointDataNV
{
using NativeType = VkCheckpointDataNV;
return *this;
}
- operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCheckpointDataNV *>( this );
}
- operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCheckpointDataNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlagBits const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stage, pCheckpointMarker );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CheckpointDataNV const & ) const = default;
#else
bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) &&
- ( pCheckpointMarker == rhs.pCheckpointMarker );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CheckpointDataNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointDataNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits, seed, checkpointDataNV.stage );
- VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pCheckpointMarker );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union ClearColorValue
{
using NativeType = VkClearColorValue;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkClearDepthStencilValue *>( this );
}
- operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkClearDepthStencilValue *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( depth, stencil );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ClearDepthStencilValue const & ) const = default;
#else
bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( depth == rhs.depth ) && ( stencil == rhs.stencil );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>::value,
"ClearDepthStencilValue is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, clearDepthStencilValue.depth );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearDepthStencilValue.stencil );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union ClearValue
{
using NativeType = VkClearValue;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkClearAttachment *>( this );
}
- operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkClearAttachment *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ClearValue const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( aspectMask, colorAttachment, clearValue );
+ }
+
public:
VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {};
uint32_t colorAttachment = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkClearRect *>( this );
}
- operator VkClearRect &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkClearRect &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkClearRect *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Rect2D const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( rect, baseArrayLayer, layerCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ClearRect const & ) const = default;
#else
- bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ClearRect>::value,
"ClearRect is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ClearRect>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, clearRect.rect );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.baseArrayLayer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.layerCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CoarseSampleLocationNV
{
using NativeType = VkCoarseSampleLocationNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCoarseSampleLocationNV *>( this );
}
- operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCoarseSampleLocationNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( pixelX, pixelY, sample );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CoarseSampleLocationNV const & ) const = default;
#else
bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>::value,
"CoarseSampleLocationNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelX );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelY );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.sample );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CoarseSampleOrderCustomNV
{
using NativeType = VkCoarseSampleOrderCustomNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( this );
}
- operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCoarseSampleOrderCustomNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default;
#else
bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) &&
- ( sampleLocationCount == rhs.sampleLocationCount ) && ( pSampleLocations == rhs.pSampleLocations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>::value,
"CoarseSampleOrderCustomNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV, seed, coarseSampleOrderCustomNV.shadingRate );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleLocationCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV *, seed, coarseSampleOrderCustomNV.pSampleLocations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferAllocateInfo
{
using NativeType = VkCommandBufferAllocateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferAllocateInfo *>( this );
}
- operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CommandPool const &,
+ VULKAN_HPP_NAMESPACE::CommandBufferLevel const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, commandPool, level, commandBufferCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferAllocateInfo const & ) const = default;
#else
bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) &&
- ( level == rhs.level ) && ( commandBufferCount == rhs.commandBufferCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferAllocateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPool, seed, commandBufferAllocateInfo.commandPool );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferLevel, seed, commandBufferAllocateInfo.level );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferAllocateInfo.commandBufferCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferInheritanceInfo
{
using NativeType = VkCommandBufferInheritanceInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferInheritanceInfo *>( this );
}
- operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferInheritanceInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RenderPass const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Framebuffer const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::QueryControlFlags const &,
+ VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferInheritanceInfo const & ) const = default;
#else
bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
- ( subpass == rhs.subpass ) && ( framebuffer == rhs.framebuffer ) &&
- ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) &&
- ( pipelineStatistics == rhs.pipelineStatistics );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferInheritanceInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, commandBufferInheritanceInfo.renderPass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceInfo.subpass );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, commandBufferInheritanceInfo.framebuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceInfo.occlusionQueryEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryControlFlags, seed, commandBufferInheritanceInfo.queryFlags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, commandBufferInheritanceInfo.pipelineStatistics );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferBeginInfo
{
using NativeType = VkCommandBufferBeginInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferBeginInfo *>( this );
}
- operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferBeginInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags const &,
+ const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pInheritanceInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferBeginInfo const & ) const = default;
#else
bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pInheritanceInfo == rhs.pInheritanceInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferBeginInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferBeginInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferBeginInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags, seed, commandBufferBeginInfo.flags );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo *, seed, commandBufferBeginInfo.pInheritanceInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferInheritanceConditionalRenderingInfoEXT
{
using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
}
- operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, conditionalRenderingEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default;
#else
bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferInheritanceConditionalRenderingInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const &
- commandBufferInheritanceConditionalRenderingInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferInheritanceRenderPassTransformInfoQCOM
{
using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
}
- operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::Rect2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, transform, renderArea );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default;
#else
bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) &&
- ( renderArea == rhs.renderArea );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const &
- commandBufferInheritanceRenderPassTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR,
- seed,
- commandBufferInheritanceRenderPassTransformInfoQCOM.transform );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Rect2D, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferInheritanceRenderingInfoKHR
{
using NativeType = VkCommandBufferInheritanceRenderingInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferInheritanceRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR *>( this );
}
- operator VkCommandBufferInheritanceRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RenderingFlagsKHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Format * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ viewMask,
+ colorAttachmentCount,
+ pColorAttachmentFormats,
+ depthAttachmentFormat,
+ stencilAttachmentFormat,
+ rasterizationSamples );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferInheritanceRenderingInfoKHR const & ) const = default;
#else
bool operator==( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
- ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
- ( depthAttachmentFormat == rhs.depthAttachmentFormat ) &&
- ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) &&
- ( rasterizationSamples == rhs.rasterizationSamples );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferInheritanceRenderingInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR const &
- commandBufferInheritanceRenderingInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderingInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceRenderingInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, commandBufferInheritanceRenderingInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.viewMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.colorAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Format *, seed, commandBufferInheritanceRenderingInfoKHR.pColorAttachmentFormats );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.depthAttachmentFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.stencilAttachmentFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, commandBufferInheritanceRenderingInfoKHR.rasterizationSamples );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct Viewport
{
using NativeType = VkViewport;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkViewport const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkViewport const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkViewport *>( this );
}
- operator VkViewport &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkViewport &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkViewport *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &, float const &, float const &, float const &, float const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y, width, height, minDepth, maxDepth );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Viewport const & ) const = default;
#else
bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) &&
- ( minDepth == rhs.minDepth ) && ( maxDepth == rhs.maxDepth );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Viewport>::value,
"Viewport is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Viewport>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, viewport.x );
- VULKAN_HPP_HASH_COMBINE( float, seed, viewport.y );
- VULKAN_HPP_HASH_COMBINE( float, seed, viewport.width );
- VULKAN_HPP_HASH_COMBINE( float, seed, viewport.height );
- VULKAN_HPP_HASH_COMBINE( float, seed, viewport.minDepth );
- VULKAN_HPP_HASH_COMBINE( float, seed, viewport.maxDepth );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferInheritanceViewportScissorInfoNV
{
using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
}
- operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Viewport * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default;
#else
bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) &&
- ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferInheritanceViewportScissorInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const &
- commandBufferInheritanceViewportScissorInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceViewportScissorInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceViewportScissorInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Viewport *, seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandBufferSubmitInfoKHR
{
using NativeType = VkCommandBufferSubmitInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandBufferSubmitInfoKHR *>( this );
}
- operator VkCommandBufferSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandBufferSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandBufferSubmitInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CommandBuffer const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, commandBuffer, deviceMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBufferSubmitInfoKHR const & ) const = default;
#else
bool operator==( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) &&
- ( deviceMask == rhs.deviceMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandBufferSubmitInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR const & commandBufferSubmitInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferSubmitInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferSubmitInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBuffer, seed, commandBufferSubmitInfoKHR.commandBuffer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferSubmitInfoKHR.deviceMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CommandPoolCreateInfo
{
using NativeType = VkCommandPoolCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCommandPoolCreateInfo *>( this );
}
- operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCommandPoolCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, queueFamilyIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandPoolCreateInfo const & ) const = default;
#else
bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( queueFamilyIndex == rhs.queueFamilyIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CommandPoolCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandPoolCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, commandPoolCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags, seed, commandPoolCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandPoolCreateInfo.queueFamilyIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SpecializationMapEntry
{
using NativeType = VkSpecializationMapEntry;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSpecializationMapEntry *>( this );
}
- operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSpecializationMapEntry *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, size_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( constantID, offset, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SpecializationMapEntry const & ) const = default;
#else
bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>::value,
"SpecializationMapEntry is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.constantID );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.offset );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationMapEntry.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SpecializationInfo
{
using NativeType = VkSpecializationInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSpecializationInfo *>( this );
}
- operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSpecializationInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SpecializationMapEntry * const &,
+ size_t const &,
+ const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( mapEntryCount, pMapEntries, dataSize, pData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SpecializationInfo const & ) const = default;
#else
bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) &&
- ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SpecializationInfo>::value,
"SpecializationInfo is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationInfo.mapEntryCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SpecializationMapEntry *, seed, specializationInfo.pMapEntries );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationInfo.dataSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, specializationInfo.pData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineShaderStageCreateInfo
{
using NativeType = VkPipelineShaderStageCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineShaderStageCreateInfo *>( this );
}
- operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineShaderStageCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlagBits const &,
+ VULKAN_HPP_NAMESPACE::ShaderModule const &,
+ const char * const &,
+ const VULKAN_HPP_NAMESPACE::SpecializationInfo * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineShaderStageCreateInfo const & ) const = default;
#else
bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) &&
- ( module == rhs.module ) && ( pName == rhs.pName ) && ( pSpecializationInfo == rhs.pSpecializationInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineShaderStageCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineShaderStageCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags, seed, pipelineShaderStageCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits, seed, pipelineShaderStageCreateInfo.stage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModule, seed, pipelineShaderStageCreateInfo.module );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, pipelineShaderStageCreateInfo.pName );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SpecializationInfo *, seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ComputePipelineCreateInfo
{
using NativeType = VkComputePipelineCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkComputePipelineCreateInfo *>( this );
}
- operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkComputePipelineCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ComputePipelineCreateInfo const & ) const = default;
#else
bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) &&
- ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) &&
- ( basePipelineIndex == rhs.basePipelineIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ComputePipelineCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, computePipelineCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, computePipelineCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, computePipelineCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo, seed, computePipelineCreateInfo.stage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, computePipelineCreateInfo.layout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, computePipelineCreateInfo.basePipelineHandle );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, computePipelineCreateInfo.basePipelineIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ConditionalRenderingBeginInfoEXT
{
using NativeType = VkConditionalRenderingBeginInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( this );
}
- operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, buffer, offset, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default;
#else
bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) &&
- ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ConditionalRenderingBeginInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, conditionalRenderingBeginInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, conditionalRenderingBeginInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, conditionalRenderingBeginInfoEXT.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, conditionalRenderingBeginInfoEXT.offset );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT, seed, conditionalRenderingBeginInfoEXT.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ConformanceVersion
{
using NativeType = VkConformanceVersion;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkConformanceVersion *>( this );
}
- operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkConformanceVersion *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint8_t const &, uint8_t const &, uint8_t const &, uint8_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( major, minor, subminor, patch );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ConformanceVersion const & ) const = default;
#else
bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"ConformanceVersion is not nothrow_move_constructible!" );
using ConformanceVersionKHR = ConformanceVersion;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.major );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.minor );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.subminor );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.patch );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CooperativeMatrixPropertiesNV
{
using NativeType = VkCooperativeMatrixPropertiesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCooperativeMatrixPropertiesNV *>( this );
}
- operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+ VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+ VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+ VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
+ VULKAN_HPP_NAMESPACE::ScopeNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default;
#else
bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CooperativeMatrixPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cooperativeMatrixPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, cooperativeMatrixPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.MSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.NSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.KSize );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.AType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.BType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.CType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.DType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ScopeNV, seed, cooperativeMatrixPropertiesNV.scope );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyAccelerationStructureInfoKHR
{
using NativeType = VkCopyAccelerationStructureInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( this );
}
- operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+ VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, src, dst, mode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default;
#else
bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) &&
- ( mode == rhs.mode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyAccelerationStructureInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyAccelerationStructureInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyAccelerationStructureInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.src );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.dst );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR, seed, copyAccelerationStructureInfoKHR.mode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyAccelerationStructureToMemoryInfoKHR
{
using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
}
- operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const &,
+ VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, src, dst, mode );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;
const void * pNext = {};
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyBufferInfo2KHR *>( this );
}
- operator VkCopyBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyBufferInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::BufferCopy2KHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyBufferInfo2KHR const & ) const = default;
#else
bool operator==( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) &&
- ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyBufferInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR const & copyBufferInfo2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.srcBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.dstBuffer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferInfo2KHR.regionCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferCopy2KHR *, seed, copyBufferInfo2KHR.pRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyBufferToImageInfo2KHR
{
using NativeType = VkCopyBufferToImageInfo2KHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( this );
}
- operator VkCopyBufferToImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyBufferToImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyBufferToImageInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyBufferToImageInfo2KHR const & ) const = default;
#else
bool operator==( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) &&
- ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) &&
- ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyBufferToImageInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR const & copyBufferToImageInfo2KHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferToImageInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferToImageInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferToImageInfo2KHR.srcBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyBufferToImageInfo2KHR.dstImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyBufferToImageInfo2KHR.dstImageLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferToImageInfo2KHR.regionCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyBufferToImageInfo2KHR.pRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyCommandTransformInfoQCOM
{
using NativeType = VkCopyCommandTransformInfoQCOM;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyCommandTransformInfoQCOM *>( this );
}
- operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyCommandTransformInfoQCOM *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, transform );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default;
#else
bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyCommandTransformInfoQCOM;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyCommandTransformInfoQCOM.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyCommandTransformInfoQCOM.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, copyCommandTransformInfoQCOM.transform );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyDescriptorSet
{
using NativeType = VkCopyDescriptorSet;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyDescriptorSet *>( this );
}
- operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyDescriptorSet *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorSet const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DescriptorSet const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyDescriptorSet const & ) const = default;
#else
bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) &&
- ( srcBinding == rhs.srcBinding ) && ( srcArrayElement == rhs.srcArrayElement ) &&
- ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) &&
- ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyDescriptorSet;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyDescriptorSet.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyDescriptorSet.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.srcSet );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcBinding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcArrayElement );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.dstSet );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstBinding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstArrayElement );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.descriptorCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageCopy2KHR
{
using NativeType = VkImageCopy2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageCopy2KHR *>( this );
}
- operator VkImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageCopy2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageCopy2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageCopy2KHR const & ) const = default;
#else
bool operator==( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
- ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) &&
- ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageCopy2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageCopy2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2KHR const & imageCopy2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCopy2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCopy2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.srcSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.srcOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.dstSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.dstOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy2KHR.extent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyImageInfo2KHR
{
using NativeType = VkCopyImageInfo2KHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyImageInfo2KHR *>( this );
}
- operator VkCopyImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyImageInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageCopy2KHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyImageInfo2KHR const & ) const = default;
#else
bool operator==( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
- ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
- ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
- ( pRegions == rhs.pRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyImageInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR const & copyImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.srcImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.srcImageLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.dstImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.dstImageLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageInfo2KHR.regionCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageCopy2KHR *, seed, copyImageInfo2KHR.pRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyImageToBufferInfo2KHR
{
using NativeType = VkCopyImageToBufferInfo2KHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( this );
}
- operator VkCopyImageToBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyImageToBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyImageToBufferInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyImageToBufferInfo2KHR const & ) const = default;
#else
bool operator==( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
- ( srcImageLayout == rhs.srcImageLayout ) && ( dstBuffer == rhs.dstBuffer ) &&
- ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CopyImageToBufferInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR const & copyImageToBufferInfo2KHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageToBufferInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageToBufferInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageToBufferInfo2KHR.srcImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageToBufferInfo2KHR.srcImageLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyImageToBufferInfo2KHR.dstBuffer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageToBufferInfo2KHR.regionCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyImageToBufferInfo2KHR.pRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CopyMemoryToAccelerationStructureInfoKHR
{
using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
}
- operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
+ VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
+ VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, src, dst, mode );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( this );
}
- operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCuFunctionCreateInfoNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CuModuleNVX const &,
+ const char * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, module, pName );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CuFunctionCreateInfoNVX const & ) const = default;
#else
bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( pName == rhs.pName );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CuFunctionCreateInfoNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuFunctionCreateInfoNVX.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, cuFunctionCreateInfoNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuModuleNVX, seed, cuFunctionCreateInfoNVX.module );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, cuFunctionCreateInfoNVX.pName );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CuLaunchInfoNVX
{
using NativeType = VkCuLaunchInfoNVX;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCuLaunchInfoNVX *>( this );
}
- operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCuLaunchInfoNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CuFunctionNVX const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ size_t const &,
+ const void * const * const &,
+ size_t const &,
+ const void * const * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ function,
+ gridDimX,
+ gridDimY,
+ gridDimZ,
+ blockDimX,
+ blockDimY,
+ blockDimZ,
+ sharedMemBytes,
+ paramCount,
+ pParams,
+ extraCount,
+ pExtras );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CuLaunchInfoNVX const & ) const = default;
#else
bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) &&
- ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && ( gridDimZ == rhs.gridDimZ ) &&
- ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) &&
- ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) &&
- ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && ( pExtras == rhs.pExtras );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CuLaunchInfoNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuLaunchInfoNVX.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, cuLaunchInfoNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuFunctionNVX, seed, cuLaunchInfoNVX.function );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimX );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimY );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimZ );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimX );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimY );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimZ );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.sharedMemBytes );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.paramCount );
- VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pParams );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.extraCount );
- VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pExtras );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct CuModuleCreateInfoNVX
{
using NativeType = VkCuModuleCreateInfoNVX;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCuModuleCreateInfoNVX *>( this );
}
- operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCuModuleCreateInfoNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, size_t const &, const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, dataSize, pData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CuModuleCreateInfoNVX const & ) const = default;
#else
bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = CuModuleCreateInfoNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuModuleCreateInfoNVX.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, cuModuleCreateInfoNVX.dataSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct D3D12FenceSubmitInfoKHR
{
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>( this );
}
- operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint64_t * const &,
+ uint32_t const &,
+ const uint64_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ waitSemaphoreValuesCount,
+ pWaitSemaphoreValues,
+ signalSemaphoreValuesCount,
+ pSignalSemaphoreValues );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default;
# else
bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) &&
- ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) &&
- ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) &&
- ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = D3D12FenceSubmitInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, d3D12FenceSubmitInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, d3D12FenceSubmitInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct DebugMarkerMarkerInfoEXT
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( this );
}
- operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const char * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pMarkerName, color );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugMarkerMarkerInfoEXT const & ) const = default;
#else
bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pMarkerName == rhs.pMarkerName ) &&
- ( color == rhs.color );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugMarkerMarkerInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerMarkerInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerMarkerInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerMarkerInfoEXT.pMarkerName );
- for ( size_t i = 0; i < 4; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, debugMarkerMarkerInfoEXT.color[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugMarkerObjectNameInfoEXT
{
using NativeType = VkDebugMarkerObjectNameInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( this );
}
- operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT const &,
+ uint64_t const &,
+ const char * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, objectType, object, pObjectName );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugMarkerObjectNameInfoEXT const & ) const = default;
#else
bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
- ( object == rhs.object ) && ( pObjectName == rhs.pObjectName );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugMarkerObjectNameInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectNameInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectNameInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectNameInfoEXT.objectType );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectNameInfoEXT.object );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerObjectNameInfoEXT.pObjectName );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugMarkerObjectTagInfoEXT
{
using NativeType = VkDebugMarkerObjectTagInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( this );
}
- operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT const &,
+ uint64_t const &,
+ uint64_t const &,
+ size_t const &,
+ const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default;
#else
bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
- ( object == rhs.object ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) &&
- ( pTag == rhs.pTag );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugMarkerObjectTagInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectTagInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectTagInfoEXT.objectType );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.object );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.tagName );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, debugMarkerObjectTagInfoEXT.tagSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pTag );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugReportCallbackCreateInfoEXT
{
using NativeType = VkDebugReportCallbackCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( this );
}
- operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT const &,
+ PFN_vkDebugReportCallbackEXT const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pfnCallback, pUserData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugReportCallbackCreateInfoEXT const & ) const = default;
#else
bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugReportCallbackCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugReportCallbackCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugReportCallbackCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT, seed, debugReportCallbackCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( PFN_vkDebugReportCallbackEXT, seed, debugReportCallbackCreateInfoEXT.pfnCallback );
- VULKAN_HPP_HASH_COMBINE( void *, seed, debugReportCallbackCreateInfoEXT.pUserData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugUtilsLabelEXT
{
using NativeType = VkDebugUtilsLabelEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugUtilsLabelEXT *>( this );
}
- operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugUtilsLabelEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const char * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pLabelName, color );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugUtilsLabelEXT const & ) const = default;
#else
bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pLabelName == rhs.pLabelName ) &&
- ( color == rhs.color );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugUtilsLabelEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsLabelEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsLabelEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsLabelEXT.pLabelName );
- for ( size_t i = 0; i < 4; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, debugUtilsLabelEXT.color[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugUtilsObjectNameInfoEXT
{
using NativeType = VkDebugUtilsObjectNameInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( this );
}
- operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ObjectType const &,
+ uint64_t const &,
+ const char * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, objectType, objectHandle, pObjectName );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugUtilsObjectNameInfoEXT const & ) const = default;
#else
bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
- ( objectHandle == rhs.objectHandle ) && ( pObjectName == rhs.pObjectName );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugUtilsObjectNameInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectNameInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectNameInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectNameInfoEXT.objectType );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectNameInfoEXT.objectHandle );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsObjectNameInfoEXT.pObjectName );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugUtilsMessengerCallbackDataEXT
{
using NativeType = VkDebugUtilsMessengerCallbackDataEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( this );
}
- operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT const &,
+ const char * const &,
+ int32_t const &,
+ const char * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ pMessageIdName,
+ messageIdNumber,
+ pMessage,
+ queueLabelCount,
+ pQueueLabels,
+ cmdBufLabelCount,
+ pCmdBufLabels,
+ objectCount,
+ pObjects );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugUtilsMessengerCallbackDataEXT const & ) const = default;
#else
bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugUtilsMessengerCallbackDataEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const &
- debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCallbackDataEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCallbackDataEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT, seed, debugUtilsMessengerCallbackDataEXT.flags );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessageIdName );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessage );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.objectCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *, seed, debugUtilsMessengerCallbackDataEXT.pObjects );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugUtilsMessengerCreateInfoEXT
{
using NativeType = VkDebugUtilsMessengerCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( this );
}
- operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT const &,
+ PFN_vkDebugUtilsMessengerCallbackEXT const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugUtilsMessengerCreateInfoEXT const & ) const = default;
#else
bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( messageSeverity == rhs.messageSeverity ) && ( messageType == rhs.messageType ) &&
- ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugUtilsMessengerCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageSeverity );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageType );
- VULKAN_HPP_HASH_COMBINE(
- PFN_vkDebugUtilsMessengerCallbackEXT, seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback );
- VULKAN_HPP_HASH_COMBINE( void *, seed, debugUtilsMessengerCreateInfoEXT.pUserData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DebugUtilsObjectTagInfoEXT
{
using NativeType = VkDebugUtilsObjectTagInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( this );
}
- operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ObjectType const &,
+ uint64_t const &,
+ uint64_t const &,
+ size_t const &,
+ const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default;
#else
bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
- ( objectHandle == rhs.objectHandle ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) &&
- ( pTag == rhs.pTag );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DebugUtilsObjectTagInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectTagInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectTagInfoEXT.objectType );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.objectHandle );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.tagName );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, debugUtilsObjectTagInfoEXT.tagSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pTag );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DedicatedAllocationBufferCreateInfoNV
{
using NativeType = VkDedicatedAllocationBufferCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>( this );
}
- operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, dedicatedAllocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default;
#else
bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DedicatedAllocationBufferCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const &
- dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationBufferCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationBufferCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DedicatedAllocationImageCreateInfoNV
{
using NativeType = VkDedicatedAllocationImageCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>( this );
}
- operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, dedicatedAllocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default;
#else
bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DedicatedAllocationImageCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const &
- dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationImageCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationImageCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DedicatedAllocationMemoryAllocateInfoNV
{
using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
}
- operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, image, buffer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default;
#else
bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DedicatedAllocationMemoryAllocateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const &
- dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationMemoryAllocateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationMemoryAllocateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, dedicatedAllocationMemoryAllocateInfoNV.image );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, dedicatedAllocationMemoryAllocateInfoNV.buffer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryBarrier2KHR
{
using NativeType = VkMemoryBarrier2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryBarrier2KHR *>( this );
}
- operator VkMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryBarrier2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryBarrier2KHR const & ) const = default;
#else
bool operator==( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
- ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
- ( dstAccessMask == rhs.dstAccessMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryBarrier2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR const & memoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.srcStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.dstStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.dstAccessMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageSubresourceRange
{
using NativeType = VkImageSubresourceRange;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageSubresourceRange *>( this );
}
- operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageSubresourceRange *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageSubresourceRange const & ) const = default;
#else
bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) &&
- ( levelCount == rhs.levelCount ) && ( baseArrayLayer == rhs.baseArrayLayer ) &&
- ( layerCount == rhs.layerCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>::value,
"ImageSubresourceRange is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceRange.aspectMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseMipLevel );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.levelCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseArrayLayer );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.layerCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageMemoryBarrier2KHR
{
using NativeType = VkImageMemoryBarrier2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageMemoryBarrier2KHR *>( this );
}
- operator VkImageMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageMemoryBarrier2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ srcStageMask,
+ srcAccessMask,
+ dstStageMask,
+ dstAccessMask,
+ oldLayout,
+ newLayout,
+ srcQueueFamilyIndex,
+ dstQueueFamilyIndex,
+ image,
+ subresourceRange );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageMemoryBarrier2KHR const & ) const = default;
#else
bool operator==( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
- ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
- ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
- ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
- ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) &&
- ( subresourceRange == rhs.subresourceRange );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageMemoryBarrier2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR const & imageMemoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.srcStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.dstStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.dstAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.oldLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.newLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.srcQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.dstQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier2KHR.image );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier2KHR.subresourceRange );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DependencyInfoKHR
{
using NativeType = VkDependencyInfoKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDependencyInfoKHR *>( this );
}
- operator VkDependencyInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDependencyInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDependencyInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DependencyFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ dependencyFlags,
+ memoryBarrierCount,
+ pMemoryBarriers,
+ bufferMemoryBarrierCount,
+ pBufferMemoryBarriers,
+ imageMemoryBarrierCount,
+ pImageMemoryBarriers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DependencyInfoKHR const & ) const = default;
#else
bool operator==( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) &&
- ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) &&
- ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) &&
- ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) &&
- ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) &&
- ( pImageMemoryBarriers == rhs.pImageMemoryBarriers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DependencyInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DependencyInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfoKHR const & dependencyInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dependencyInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, dependencyInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, dependencyInfoKHR.dependencyFlags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.memoryBarrierCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR *, seed, dependencyInfoKHR.pMemoryBarriers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.bufferMemoryBarrierCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR *, seed, dependencyInfoKHR.pBufferMemoryBarriers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.imageMemoryBarrierCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR *, seed, dependencyInfoKHR.pImageMemoryBarriers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorBufferInfo
{
using NativeType = VkDescriptorBufferInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorBufferInfo *>( this );
}
- operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorBufferInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( buffer, offset, range );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorBufferInfo const & ) const = default;
#else
bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>::value,
"DescriptorBufferInfo is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, descriptorBufferInfo.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.range );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorImageInfo
{
using NativeType = VkDescriptorImageInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorImageInfo *>( this );
}
- operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorImageInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Sampler const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sampler, imageView, imageLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorImageInfo const & ) const = default;
#else
bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>::value,
"DescriptorImageInfo is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, descriptorImageInfo.sampler );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, descriptorImageInfo.imageView );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, descriptorImageInfo.imageLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorPoolSize
{
using NativeType = VkDescriptorPoolSize;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorPoolSize *>( this );
}
- operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorPoolSize *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DescriptorType const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( type, descriptorCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorPoolSize const & ) const = default;
#else
bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>::value,
"DescriptorPoolSize is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorPoolSize.type );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolSize.descriptorCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorPoolCreateInfo
{
using NativeType = VkDescriptorPoolCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorPoolCreateInfo *>( this );
}
- operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorPoolCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorPoolSize * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorPoolCreateInfo const & ) const = default;
#else
bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) &&
- ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DescriptorPoolCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags, seed, descriptorPoolCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.maxSets );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.poolSizeCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DescriptorPoolSize *, seed, descriptorPoolCreateInfo.pPoolSizes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorPoolInlineUniformBlockCreateInfoEXT
{
using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>( this );
}
- operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxInlineUniformBlockBindings );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const & ) const = default;
#else
bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT const &
- descriptorPoolInlineUniformBlockCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.maxInlineUniformBlockBindings );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetAllocateInfo
{
using NativeType = VkDescriptorSetAllocateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetAllocateInfo *>( this );
}
- operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorPool const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetAllocateInfo const & ) const = default;
#else
bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) &&
- ( descriptorSetCount == rhs.descriptorSetCount ) && ( pSetLayouts == rhs.pSetLayouts );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DescriptorSetAllocateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPool, seed, descriptorSetAllocateInfo.descriptorPool );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetAllocateInfo.descriptorSetCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, descriptorSetAllocateInfo.pSetLayouts );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetLayoutBinding
{
using NativeType = VkDescriptorSetLayoutBinding;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetLayoutBinding *>( this );
}
- operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetLayoutBinding *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DescriptorType const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+ const VULKAN_HPP_NAMESPACE::Sampler * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetLayoutBinding const & ) const = default;
#else
bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) &&
- ( descriptorCount == rhs.descriptorCount ) && ( stageFlags == rhs.stageFlags ) &&
- ( pImmutableSamplers == rhs.pImmutableSamplers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>::value,
"DescriptorSetLayoutBinding is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.binding );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorSetLayoutBinding.descriptorType );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.descriptorCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, descriptorSetLayoutBinding.stageFlags );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Sampler *, seed, descriptorSetLayoutBinding.pImmutableSamplers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetLayoutBindingFlagsCreateInfo
{
using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
}
- operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, bindingCount, pBindingFlags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default;
#else
bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) &&
- ( pBindingFlags == rhs.pBindingFlags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const &
- descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutBindingFlagsCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags *,
- seed,
- descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetLayoutCreateInfo
{
using NativeType = VkDescriptorSetLayoutCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( this );
}
- operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, bindingCount, pBindings );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default;
#else
bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( bindingCount == rhs.bindingCount ) && ( pBindings == rhs.pBindings );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DescriptorSetLayoutCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags, seed, descriptorSetLayoutCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutCreateInfo.bindingCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding *, seed, descriptorSetLayoutCreateInfo.pBindings );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetLayoutSupport
{
using NativeType = VkDescriptorSetLayoutSupport;
return *this;
}
- operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetLayoutSupport *>( this );
}
- operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetLayoutSupport *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, supported );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetLayoutSupport const & ) const = default;
#else
bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutSupport.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetLayoutSupport.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, descriptorSetLayoutSupport.supported );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetVariableDescriptorCountAllocateInfo
{
using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
}
- operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default;
#else
bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
- ( pDescriptorCounts == rhs.pDescriptorCounts );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const &
- descriptorSetVariableDescriptorCountAllocateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount );
- VULKAN_HPP_HASH_COMBINE(
- const uint32_t *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorSetVariableDescriptorCountLayoutSupport
{
using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport;
return *this;
}
- operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
}
- operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxVariableDescriptorCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default;
#else
bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const &
- descriptorSetVariableDescriptorCountLayoutSupport ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountLayoutSupport.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorUpdateTemplateEntry
{
using NativeType = VkDescriptorUpdateTemplateEntry;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry *>( this );
}
- operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorUpdateTemplateEntry *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DescriptorType const &,
+ size_t const &,
+ size_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default;
#else
bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) &&
- ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) &&
- ( offset == rhs.offset ) && ( stride == rhs.stride );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"DescriptorUpdateTemplateEntry is not nothrow_move_constructible!" );
using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstBinding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstArrayElement );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.descriptorCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorUpdateTemplateEntry.descriptorType );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.offset );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.stride );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DescriptorUpdateTemplateCreateInfo
{
using NativeType = VkDescriptorUpdateTemplateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( this );
}
- operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType const &,
+ VULKAN_HPP_NAMESPACE::DescriptorSetLayout const &,
+ VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ descriptorUpdateEntryCount,
+ pDescriptorUpdateEntries,
+ templateType,
+ descriptorSetLayout,
+ pipelineBindPoint,
+ pipelineLayout,
+ set );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default;
#else
bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &
- descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorUpdateTemplateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorUpdateTemplateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags, seed, descriptorUpdateTemplateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry *,
- seed,
- descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType, seed, descriptorUpdateTemplateCreateInfo.templateType );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DescriptorSetLayout, seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineLayout, seed, descriptorUpdateTemplateCreateInfo.pipelineLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.set );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceBufferMemoryRequirementsKHR
{
using NativeType = VkDeviceBufferMemoryRequirementsKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceBufferMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceBufferMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceBufferMemoryRequirementsKHR *>( this );
}
- operator VkDeviceBufferMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceBufferMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceBufferMemoryRequirementsKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const VULKAN_HPP_NAMESPACE::BufferCreateInfo * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pCreateInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceBufferMemoryRequirementsKHR const & ) const = default;
#else
bool operator==( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceBufferMemoryRequirementsKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR const &
- deviceBufferMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceBufferMemoryRequirementsKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceBufferMemoryRequirementsKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::BufferCreateInfo *, seed, deviceBufferMemoryRequirementsKHR.pCreateInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceQueueCreateInfo
{
using NativeType = VkDeviceQueueCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceQueueCreateInfo *>( this );
}
- operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceQueueCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ const float * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceQueueCreateInfo const & ) const = default;
#else
bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueCount == rhs.queueCount ) &&
- ( pQueuePriorities == rhs.pQueuePriorities );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceQueueCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueCount );
- VULKAN_HPP_HASH_COMBINE( const float *, seed, deviceQueueCreateInfo.pQueuePriorities );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFeatures
{
using NativeType = VkPhysicalDeviceFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFeatures *>( this );
}
- operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( robustBufferAccess,
+ fullDrawIndexUint32,
+ imageCubeArray,
+ independentBlend,
+ geometryShader,
+ tessellationShader,
+ sampleRateShading,
+ dualSrcBlend,
+ logicOp,
+ multiDrawIndirect,
+ drawIndirectFirstInstance,
+ depthClamp,
+ depthBiasClamp,
+ fillModeNonSolid,
+ depthBounds,
+ wideLines,
+ largePoints,
+ alphaToOne,
+ multiViewport,
+ samplerAnisotropy,
+ textureCompressionETC2,
+ textureCompressionASTC_LDR,
+ textureCompressionBC,
+ occlusionQueryPrecise,
+ pipelineStatisticsQuery,
+ vertexPipelineStoresAndAtomics,
+ fragmentStoresAndAtomics,
+ shaderTessellationAndGeometryPointSize,
+ shaderImageGatherExtended,
+ shaderStorageImageExtendedFormats,
+ shaderStorageImageMultisample,
+ shaderStorageImageReadWithoutFormat,
+ shaderStorageImageWriteWithoutFormat,
+ shaderUniformBufferArrayDynamicIndexing,
+ shaderSampledImageArrayDynamicIndexing,
+ shaderStorageBufferArrayDynamicIndexing,
+ shaderStorageImageArrayDynamicIndexing,
+ shaderClipDistance,
+ shaderCullDistance,
+ shaderFloat64,
+ shaderInt64,
+ shaderInt16,
+ shaderResourceResidency,
+ shaderResourceMinLod,
+ sparseBinding,
+ sparseResidencyBuffer,
+ sparseResidencyImage2D,
+ sparseResidencyImage3D,
+ sparseResidency2Samples,
+ sparseResidency4Samples,
+ sparseResidency8Samples,
+ sparseResidency16Samples,
+ sparseResidencyAliased,
+ variableMultisampleRate,
+ inheritedQueries );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>::value,
"PhysicalDeviceFeatures is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.robustBufferAccess );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fullDrawIndexUint32 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.imageCubeArray );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.independentBlend );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.geometryShader );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.tessellationShader );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sampleRateShading );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.dualSrcBlend );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.logicOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiDrawIndirect );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.drawIndirectFirstInstance );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthClamp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBiasClamp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fillModeNonSolid );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBounds );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.wideLines );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.largePoints );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.alphaToOne );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiViewport );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.samplerAnisotropy );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionETC2 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionASTC_LDR );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionBC );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.occlusionQueryPrecise );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.pipelineStatisticsQuery );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fragmentStoresAndAtomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderImageGatherExtended );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageMultisample );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderClipDistance );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderCullDistance );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderFloat64 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt64 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt16 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceResidency );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceMinLod );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseBinding );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage2D );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage3D );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency2Samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency4Samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency8Samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency16Samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyAliased );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.variableMultisampleRate );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.inheritedQueries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceCreateInfo
{
using NativeType = VkDeviceCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceCreateInfo *>( this );
}
- operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo * const &,
+ uint32_t const &,
+ const char * const * const &,
+ uint32_t const &,
+ const char * const * const &,
+ const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ queueCreateInfoCount,
+ pQueueCreateInfos,
+ enabledLayerCount,
+ ppEnabledLayerNames,
+ enabledExtensionCount,
+ ppEnabledExtensionNames,
+ pEnabledFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceCreateInfo const & ) const = default;
#else
bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceCreateFlags, seed, deviceCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.queueCreateInfoCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo *, seed, deviceCreateInfo.pQueueCreateInfos );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledLayerCount );
- VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledLayerNames );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledExtensionCount );
- VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledExtensionNames );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures *, seed, deviceCreateInfo.pEnabledFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceDeviceMemoryReportCreateInfoEXT
{
using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>( this );
}
- operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
+ PFN_vkDeviceMemoryReportCallbackEXT const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pfnUserCallback, pUserData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceDeviceMemoryReportCreateInfoEXT const & ) const = default;
#else
bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceDeviceMemoryReportCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const &
- deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDeviceMemoryReportCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- PFN_vkDeviceMemoryReportCallbackEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback );
- VULKAN_HPP_HASH_COMBINE( void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceDiagnosticsConfigCreateInfoNV
{
using NativeType = VkDeviceDiagnosticsConfigCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>( this );
}
- operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default;
#else
bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceDiagnosticsConfigCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const &
- deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDiagnosticsConfigCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDiagnosticsConfigCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV, seed, deviceDiagnosticsConfigCreateInfoNV.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceEventInfoEXT
{
using NativeType = VkDeviceEventInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceEventInfoEXT *>( this );
}
- operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceEventInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceEvent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceEventInfoEXT const & ) const = default;
#else
bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceEventInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceEventInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceEventInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT, seed, deviceEventInfoEXT.deviceEvent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupBindSparseInfo
{
using NativeType = VkDeviceGroupBindSparseInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupBindSparseInfo *>( this );
}
- operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupBindSparseInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default;
#else
bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) &&
- ( memoryDeviceIndex == rhs.memoryDeviceIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupBindSparseInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupBindSparseInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.resourceDeviceIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.memoryDeviceIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupCommandBufferBeginInfo
{
using NativeType = VkDeviceGroupCommandBufferBeginInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>( this );
}
- operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default;
#else
bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const &
- deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupCommandBufferBeginInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupCommandBufferBeginInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupCommandBufferBeginInfo.deviceMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupDeviceCreateInfo
{
using NativeType = VkDeviceGroupDeviceCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>( this );
}
- operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PhysicalDevice * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default;
#else
bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
- ( pPhysicalDevices == rhs.pPhysicalDevices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupDeviceCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupDeviceCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupDeviceCreateInfo.physicalDeviceCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PhysicalDevice *, seed, deviceGroupDeviceCreateInfo.pPhysicalDevices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupPresentCapabilitiesKHR
{
using NativeType = VkDeviceGroupPresentCapabilitiesKHR;
return *this;
}
- operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR *>( this );
}
- operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, VK_MAX_DEVICE_GROUP_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, presentMask, modes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default;
#else
bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) &&
- ( modes == rhs.modes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceGroupPresentCapabilitiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const &
- deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentCapabilitiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, deviceGroupPresentCapabilitiesKHR.pNext );
- for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] );
- }
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupPresentCapabilitiesKHR.modes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupPresentInfoKHR
{
using NativeType = VkDeviceGroupPresentInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>( this );
}
- operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupPresentInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default;
#else
bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
- ( pDeviceMasks == rhs.pDeviceMasks ) && ( mode == rhs.mode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceGroupPresentInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupPresentInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentInfoKHR.swapchainCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupPresentInfoKHR.pDeviceMasks );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR, seed, deviceGroupPresentInfoKHR.mode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupRenderPassBeginInfo
{
using NativeType = VkDeviceGroupRenderPassBeginInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>( this );
}
- operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default;
#else
bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) &&
- ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupRenderPassBeginInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupRenderPassBeginInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Rect2D *, seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupSubmitInfo
{
using NativeType = VkDeviceGroupSubmitInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupSubmitInfo *>( this );
}
- operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupSubmitInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ waitSemaphoreCount,
+ pWaitSemaphoreDeviceIndices,
+ commandBufferCount,
+ pCommandBufferDeviceMasks,
+ signalSemaphoreCount,
+ pSignalSemaphoreDeviceIndices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupSubmitInfo const & ) const = default;
#else
bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
- ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) &&
- ( commandBufferCount == rhs.commandBufferCount ) &&
- ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) &&
- ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
- ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSubmitInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSubmitInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.waitSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.commandBufferCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.signalSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceGroupSwapchainCreateInfoKHR
{
using NativeType = VkDeviceGroupSwapchainCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>( this );
}
- operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, modes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default;
#else
bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceGroupSwapchainCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const &
- deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSwapchainCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSwapchainCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupSwapchainCreateInfoKHR.modes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageCreateInfo
{
using NativeType = VkImageCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageCreateInfo *>( this );
}
- operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::ImageType const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::ImageTiling const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::SharingMode const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ imageType,
+ format,
+ extent,
+ mipLevels,
+ arrayLayers,
+ samples,
+ tiling,
+ usage,
+ sharingMode,
+ queueFamilyIndexCount,
+ pQueueFamilyIndices,
+ initialLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageCreateInfo const & ) const = default;
#else
bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( imageType == rhs.imageType ) && ( format == rhs.format ) && ( extent == rhs.extent ) &&
- ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) &&
- ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) &&
- ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
- ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( initialLayout == rhs.initialLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, imageCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, imageCreateInfo.imageType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageCreateInfo.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCreateInfo.extent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.mipLevels );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.arrayLayers );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, imageCreateInfo.samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, imageCreateInfo.tiling );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageCreateInfo.usage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, imageCreateInfo.sharingMode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.queueFamilyIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, imageCreateInfo.pQueueFamilyIndices );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageCreateInfo.initialLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceImageMemoryRequirementsKHR
{
using NativeType = VkDeviceImageMemoryRequirementsKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceImageMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceImageMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceImageMemoryRequirementsKHR *>( this );
}
- operator VkDeviceImageMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceImageMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceImageMemoryRequirementsKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const VULKAN_HPP_NAMESPACE::ImageCreateInfo * const &,
+ VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pCreateInfo, planeAspect );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceImageMemoryRequirementsKHR const & ) const = default;
#else
bool operator==( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) &&
- ( planeAspect == rhs.planeAspect );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceImageMemoryRequirementsKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR const & deviceImageMemoryRequirementsKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceImageMemoryRequirementsKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceImageMemoryRequirementsKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::ImageCreateInfo *, seed, deviceImageMemoryRequirementsKHR.pCreateInfo );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, deviceImageMemoryRequirementsKHR.planeAspect );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceMemoryOpaqueCaptureAddressInfo
{
using NativeType = VkDeviceMemoryOpaqueCaptureAddressInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( this );
}
- operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default;
#else
bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const &
- deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOpaqueCaptureAddressInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOpaqueCaptureAddressInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, deviceMemoryOpaqueCaptureAddressInfo.memory );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceMemoryOverallocationCreateInfoAMD
{
using NativeType = VkDeviceMemoryOverallocationCreateInfoAMD;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>( this );
}
- operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, overallocationBehavior );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default;
#else
bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( overallocationBehavior == rhs.overallocationBehavior );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceMemoryOverallocationCreateInfoAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const &
- deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOverallocationCreateInfoAMD.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOverallocationCreateInfoAMD.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD,
- seed,
- deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceMemoryReportCallbackDataEXT
{
using NativeType = VkDeviceMemoryReportCallbackDataEXT;
return *this;
}
- operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT *>( this );
}
- operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::ObjectType const &,
+ uint64_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default;
#else
bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) &&
- ( memoryObjectId == rhs.memoryObjectId ) && ( size == rhs.size ) && ( objectType == rhs.objectType ) &&
- ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceMemoryReportCallbackDataEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const &
- deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryReportCallbackDataEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, deviceMemoryReportCallbackDataEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceMemoryReportCallbackDataEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT, seed, deviceMemoryReportCallbackDataEXT.type );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.memoryObjectId );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, deviceMemoryReportCallbackDataEXT.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, deviceMemoryReportCallbackDataEXT.objectType );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.objectHandle );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceMemoryReportCallbackDataEXT.heapIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DevicePrivateDataCreateInfoEXT
{
using NativeType = VkDevicePrivateDataCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT *>( this );
}
- operator VkDevicePrivateDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDevicePrivateDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDevicePrivateDataCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, privateDataSlotRequestCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DevicePrivateDataCreateInfoEXT const & ) const = default;
#else
bool operator==( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DevicePrivateDataCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT const & devicePrivateDataCreateInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, devicePrivateDataCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, devicePrivateDataCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, devicePrivateDataCreateInfoEXT.privateDataSlotRequestCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceQueueGlobalPriorityCreateInfoEXT
{
using NativeType = VkDeviceQueueGlobalPriorityCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT *>( this );
}
- operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, globalPriority );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const & ) const = default;
#else
bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceQueueGlobalPriorityCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT const &
- deviceQueueGlobalPriorityCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueGlobalPriorityCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueGlobalPriorityCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, deviceQueueGlobalPriorityCreateInfoEXT.globalPriority );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DeviceQueueInfo2
{
using NativeType = VkDeviceQueueInfo2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceQueueInfo2 *>( this );
}
- operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceQueueInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceQueueInfo2 const & ) const = default;
#else
bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueIndex == rhs.queueIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DeviceQueueInfo2;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueInfo2.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
struct DirectFBSurfaceCreateInfoEXT
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( this );
}
- operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT const &,
+ IDirectFB * const &,
+ IDirectFBSurface * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, dfb, surface );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default;
# else
bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) &&
- ( surface == rhs.surface );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = DirectFBSurfaceCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, directFBSurfaceCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, directFBSurfaceCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT, seed, directFBSurfaceCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( IDirectFB *, seed, directFBSurfaceCreateInfoEXT.dfb );
- VULKAN_HPP_HASH_COMBINE( IDirectFBSurface *, seed, directFBSurfaceCreateInfoEXT.surface );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
struct DispatchIndirectCommand
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDispatchIndirectCommand *>( this );
}
- operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDispatchIndirectCommand *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y, z );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DispatchIndirectCommand const & ) const = default;
#else
bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>::value,
"DispatchIndirectCommand is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.x );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.y );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.z );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayEventInfoEXT
{
using NativeType = VkDisplayEventInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayEventInfoEXT *>( this );
}
- operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayEventInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, displayEvent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayEventInfoEXT const & ) const = default;
#else
bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayEventInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayEventInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, displayEventInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT, seed, displayEventInfoEXT.displayEvent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayModeParametersKHR
{
using NativeType = VkDisplayModeParametersKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayModeParametersKHR *>( this );
}
- operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayModeParametersKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Extent2D const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( visibleRegion, refreshRate );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayModeParametersKHR const & ) const = default;
#else
bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>::value,
"DisplayModeParametersKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayModeParametersKHR.visibleRegion );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayModeParametersKHR.refreshRate );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayModeCreateInfoKHR
{
using NativeType = VkDisplayModeCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( this );
}
- operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayModeCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, parameters );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default;
#else
bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( parameters == rhs.parameters );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayModeCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, displayModeCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR, seed, displayModeCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModeCreateInfoKHR.parameters );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayModePropertiesKHR
{
using NativeType = VkDisplayModePropertiesKHR;
return *this;
}
- operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayModePropertiesKHR *>( this );
}
- operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayModePropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DisplayModeKHR const &, VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( displayMode, parameters );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayModePropertiesKHR const & ) const = default;
#else
bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
"DisplayModePropertiesKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayModePropertiesKHR.displayMode );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModePropertiesKHR.parameters );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayModeProperties2KHR
{
using NativeType = VkDisplayModeProperties2KHR;
return *this;
}
- operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayModeProperties2KHR *>( this );
}
- operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayModeProperties2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, displayModeProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayModeProperties2KHR const & ) const = default;
#else
bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayModeProperties2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeProperties2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, displayModeProperties2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, seed, displayModeProperties2KHR.displayModeProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayNativeHdrSurfaceCapabilitiesAMD
{
using NativeType = VkDisplayNativeHdrSurfaceCapabilitiesAMD;
return *this;
}
- operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>( this );
}
- operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, localDimmingSupport );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default;
#else
bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayNativeHdrSurfaceCapabilitiesAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const &
- displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayNativeHdrSurfaceCapabilitiesAMD.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPlaneCapabilitiesKHR
{
using NativeType = VkDisplayPlaneCapabilitiesKHR;
return *this;
}
- operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR *>( this );
}
- operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( supportedAlpha,
+ minSrcPosition,
+ maxSrcPosition,
+ minSrcExtent,
+ maxSrcExtent,
+ minDstPosition,
+ maxDstPosition,
+ minDstExtent,
+ maxDstExtent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default;
#else
bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) &&
- ( maxSrcPosition == rhs.maxSrcPosition ) && ( minSrcExtent == rhs.minSrcExtent ) &&
- ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) &&
- ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) &&
- ( maxDstExtent == rhs.maxDstExtent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::value,
"DisplayPlaneCapabilitiesKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR, seed, displayPlaneCapabilitiesKHR.supportedAlpha );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minSrcPosition );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxSrcPosition );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minSrcExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxSrcExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minDstPosition );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxDstPosition );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minDstExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxDstExtent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPlaneCapabilities2KHR
{
using NativeType = VkDisplayPlaneCapabilities2KHR;
return *this;
}
- operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR *>( this );
}
- operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, capabilities );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default;
#else
bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayPlaneCapabilities2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneCapabilities2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneCapabilities2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR, seed, displayPlaneCapabilities2KHR.capabilities );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPlaneInfo2KHR
{
using NativeType = VkDisplayPlaneInfo2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( this );
}
- operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPlaneInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayModeKHR const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, mode, planeIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default;
#else
bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) &&
- ( planeIndex == rhs.planeIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayPlaneInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPlaneInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayPlaneInfo2KHR.mode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlaneInfo2KHR.planeIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPlanePropertiesKHR
{
using NativeType = VkDisplayPlanePropertiesKHR;
return *this;
}
- operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPlanePropertiesKHR *>( this );
}
- operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPlanePropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DisplayKHR const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( currentDisplay, currentStackIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default;
#else
bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
"DisplayPlanePropertiesKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPlanePropertiesKHR.currentDisplay );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlanePropertiesKHR.currentStackIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPlaneProperties2KHR
{
using NativeType = VkDisplayPlaneProperties2KHR;
return *this;
}
- operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPlaneProperties2KHR *>( this );
}
- operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPlaneProperties2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, displayPlaneProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default;
#else
bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( displayPlaneProperties == rhs.displayPlaneProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayPlaneProperties2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneProperties2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneProperties2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, seed, displayPlaneProperties2KHR.displayPlaneProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPowerInfoEXT
{
using NativeType = VkDisplayPowerInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPowerInfoEXT *>( this );
}
- operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPowerInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, powerState );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPowerInfoEXT const & ) const = default;
#else
bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayPowerInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPowerInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPowerInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT, seed, displayPowerInfoEXT.powerState );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPresentInfoKHR
{
using NativeType = VkDisplayPresentInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPresentInfoKHR *>( this );
}
- operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPresentInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Rect2D const &,
+ VULKAN_HPP_NAMESPACE::Rect2D const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcRect, dstRect, persistent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPresentInfoKHR const & ) const = default;
#else
bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) &&
- ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayPresentInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPresentInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPresentInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.srcRect );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.dstRect );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPresentInfoKHR.persistent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayPropertiesKHR
{
using NativeType = VkDisplayPropertiesKHR;
return *this;
}
- operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayPropertiesKHR *>( this );
}
- operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayPropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DisplayKHR const &,
+ const char * const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( display,
+ displayName,
+ physicalDimensions,
+ physicalResolution,
+ supportedTransforms,
+ planeReorderPossible,
+ persistentContent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayPropertiesKHR const & ) const = default;
#else
bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( display == rhs.display ) && ( displayName == rhs.displayName ) &&
- ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) &&
- ( supportedTransforms == rhs.supportedTransforms ) &&
- ( planeReorderPossible == rhs.planeReorderPossible ) && ( persistentContent == rhs.persistentContent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
"DisplayPropertiesKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPropertiesKHR.display );
- VULKAN_HPP_HASH_COMBINE( const char *, seed, displayPropertiesKHR.displayName );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalDimensions );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalResolution );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, displayPropertiesKHR.supportedTransforms );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.planeReorderPossible );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.persistentContent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplayProperties2KHR
{
using NativeType = VkDisplayProperties2KHR;
return *this;
}
- operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplayProperties2KHR *>( this );
}
- operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplayProperties2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, displayProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayProperties2KHR const & ) const = default;
#else
bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplayProperties2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayProperties2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, displayProperties2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, seed, displayProperties2KHR.displayProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DisplaySurfaceCreateInfoKHR
{
using NativeType = VkDisplaySurfaceCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( this );
}
- operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::DisplayModeKHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+ float const &,
+ VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default;
#else
bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( displayMode == rhs.displayMode ) && ( planeIndex == rhs.planeIndex ) &&
- ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) &&
- ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DisplaySurfaceCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displaySurfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, displaySurfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR, seed, displaySurfaceCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displaySurfaceCreateInfoKHR.displayMode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeStackIndex );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.transform );
- VULKAN_HPP_HASH_COMBINE( float, seed, displaySurfaceCreateInfoKHR.globalAlpha );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.alphaMode );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displaySurfaceCreateInfoKHR.imageExtent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrawIndexedIndirectCommand
{
using NativeType = VkDrawIndexedIndirectCommand;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrawIndexedIndirectCommand *>( this );
}
- operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrawIndexedIndirectCommand *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, int32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrawIndexedIndirectCommand const & ) const = default;
#else
bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) &&
- ( firstIndex == rhs.firstIndex ) && ( vertexOffset == rhs.vertexOffset ) &&
- ( firstInstance == rhs.firstInstance );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>::value,
"DrawIndexedIndirectCommand is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.indexCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.instanceCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstIndex );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, drawIndexedIndirectCommand.vertexOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstInstance );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrawIndirectCommand
{
using NativeType = VkDrawIndirectCommand;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrawIndirectCommand *>( this );
}
- operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrawIndirectCommand *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( vertexCount, instanceCount, firstVertex, firstInstance );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrawIndirectCommand const & ) const = default;
#else
bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) &&
- ( firstVertex == rhs.firstVertex ) && ( firstInstance == rhs.firstInstance );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>::value,
"DrawIndirectCommand is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.vertexCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.instanceCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstVertex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstInstance );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrawMeshTasksIndirectCommandNV
{
using NativeType = VkDrawMeshTasksIndirectCommandNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV *>( this );
}
- operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( taskCount, firstTask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default;
#else
bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>::value,
"DrawMeshTasksIndirectCommandNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.taskCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.firstTask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrmFormatModifierProperties2EXT
{
using NativeType = VkDrmFormatModifierProperties2EXT;
return *this;
}
- operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrmFormatModifierProperties2EXT *>( this );
}
- operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrmFormatModifierProperties2EXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default;
#else
bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( drmFormatModifier == rhs.drmFormatModifier ) &&
- ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
- ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>::value,
"DrmFormatModifierProperties2EXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierProperties2EXT.drmFormatModifier );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR,
- seed,
- drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrmFormatModifierPropertiesEXT
{
using NativeType = VkDrmFormatModifierPropertiesEXT;
return *this;
}
- operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT *>( this );
}
- operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default;
#else
bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( drmFormatModifier == rhs.drmFormatModifier ) &&
- ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
- ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>::value,
"DrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifier );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrmFormatModifierPropertiesList2EXT
{
using NativeType = VkDrmFormatModifierPropertiesList2EXT;
return *this;
}
- operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT *>( this );
}
- operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default;
#else
bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
- ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DrmFormatModifierPropertiesList2EXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const &
- drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesList2EXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesList2EXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT *,
- seed,
- drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct DrmFormatModifierPropertiesListEXT
{
using NativeType = VkDrmFormatModifierPropertiesListEXT;
return *this;
}
- operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>( this );
}
- operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default;
#else
bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
- ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = DrmFormatModifierPropertiesListEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const &
- drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesListEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesListEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT *,
- seed,
- drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct EventCreateInfo
{
using NativeType = VkEventCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkEventCreateInfo *>( this );
}
- operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkEventCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::EventCreateFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( EventCreateInfo const & ) const = default;
#else
bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = EventCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, eventCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, eventCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::EventCreateFlags, seed, eventCreateInfo.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExportFenceCreateInfo
{
using NativeType = VkExportFenceCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportFenceCreateInfo *>( this );
}
- operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportFenceCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportFenceCreateInfo const & ) const = default;
#else
bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, exportFenceCreateInfo.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ExportFenceWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>( this );
}
- operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const SECURITY_ATTRIBUTES * const &,
+ DWORD const &,
+ LPCWSTR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pAttributes, dwAccess, name );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
- ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ExportFenceWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportFenceWin32HandleInfoKHR.pAttributes );
- VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportFenceWin32HandleInfoKHR.dwAccess );
- VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportFenceWin32HandleInfoKHR.name );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct ExportMemoryAllocateInfo
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportMemoryAllocateInfo *>( this );
}
- operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportMemoryAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportMemoryAllocateInfo const & ) const = default;
#else
bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, exportMemoryAllocateInfo.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExportMemoryAllocateInfoNV
{
using NativeType = VkExportMemoryAllocateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportMemoryAllocateInfoNV *>( this );
}
- operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportMemoryAllocateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default;
#else
bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ExportMemoryAllocateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, exportMemoryAllocateInfoNV.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ExportMemoryWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>( this );
}
- operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const SECURITY_ATTRIBUTES * const &,
+ DWORD const &,
+ LPCWSTR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pAttributes, dwAccess, name );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
- ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ExportMemoryWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoKHR.pAttributes );
- VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoKHR.dwAccess );
- VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportMemoryWin32HandleInfoKHR.name );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>( this );
}
- operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const SECURITY_ATTRIBUTES * const &,
+ DWORD const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pAttributes, dwAccess );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default;
# else
bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
- ( dwAccess == rhs.dwAccess );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ExportMemoryWin32HandleInfoNV;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoNV.pAttributes );
- VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoNV.dwAccess );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct ExportSemaphoreCreateInfo
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportSemaphoreCreateInfo *>( this );
}
- operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportSemaphoreCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default;
#else
bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, exportSemaphoreCreateInfo.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ExportSemaphoreWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>( this );
}
- operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const SECURITY_ATTRIBUTES * const &,
+ DWORD const &,
+ LPCWSTR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pAttributes, dwAccess, name );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
- ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ExportSemaphoreWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const &
- exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportSemaphoreWin32HandleInfoKHR.pAttributes );
- VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportSemaphoreWin32HandleInfoKHR.dwAccess );
- VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportSemaphoreWin32HandleInfoKHR.name );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct ExtensionProperties
return *this;
}
- operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExtensionProperties *>( this );
}
- operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExtensionProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( extensionName, specVersion );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExtensionProperties const & ) const = default;
#else
bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExtensionProperties>::value,
"ExtensionProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, extensionProperties.extensionName[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extensionProperties.specVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalMemoryProperties
{
using NativeType = VkExternalMemoryProperties;
return *this;
}
- operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalMemoryProperties *>( this );
}
- operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalMemoryProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalMemoryProperties const & ) const = default;
#else
bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) &&
- ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
- ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"ExternalMemoryProperties is not nothrow_move_constructible!" );
using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags, seed, externalMemoryProperties.externalMemoryFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags,
- seed,
- externalMemoryProperties.exportFromImportedHandleTypes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryProperties.compatibleHandleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalBufferProperties
{
using NativeType = VkExternalBufferProperties;
return *this;
}
- operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalBufferProperties *>( this );
}
- operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalBufferProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, externalMemoryProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalBufferProperties const & ) const = default;
#else
bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( externalMemoryProperties == rhs.externalMemoryProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExternalBufferPropertiesKHR = ExternalBufferProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalBufferProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, externalBufferProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalBufferProperties.externalMemoryProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalFenceProperties
{
using NativeType = VkExternalFenceProperties;
return *this;
}
- operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalFenceProperties *>( this );
}
- operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalFenceProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalFenceProperties const & ) const = default;
#else
bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
- ( compatibleHandleTypes == rhs.compatibleHandleTypes ) &&
- ( externalFenceFeatures == rhs.externalFenceFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExternalFencePropertiesKHR = ExternalFenceProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFenceProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, externalFenceProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.exportFromImportedHandleTypes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.compatibleHandleTypes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags, seed, externalFenceProperties.externalFenceFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
struct ExternalFormatANDROID
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalFormatANDROID *>( this );
}
- operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalFormatANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, externalFormat );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalFormatANDROID const & ) const = default;
# else
bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ExternalFormatANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFormatANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, externalFormatANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, externalFormatANDROID.externalFormat );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
struct ExternalImageFormatProperties
return *this;
}
- operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalImageFormatProperties *>( this );
}
- operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalImageFormatProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, externalMemoryProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalImageFormatProperties const & ) const = default;
#else
bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( externalMemoryProperties == rhs.externalMemoryProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalImageFormatProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, externalImageFormatProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalImageFormatProperties.externalMemoryProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageFormatProperties
{
using NativeType = VkImageFormatProperties;
return *this;
}
- operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageFormatProperties *>( this );
}
- operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageFormatProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Extent3D const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageFormatProperties const & ) const = default;
#else
bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) &&
- ( maxArrayLayers == rhs.maxArrayLayers ) && ( sampleCounts == rhs.sampleCounts ) &&
- ( maxResourceSize == rhs.maxResourceSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::value,
"ImageFormatProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageFormatProperties.maxExtent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxMipLevels );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxArrayLayers );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, imageFormatProperties.sampleCounts );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageFormatProperties.maxResourceSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalImageFormatPropertiesNV
{
using NativeType = VkExternalImageFormatPropertiesNV;
return *this;
}
- operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalImageFormatPropertiesNV *>( this );
}
- operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalImageFormatPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageFormatProperties const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default;
#else
bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( imageFormatProperties == rhs.imageFormatProperties ) &&
- ( externalMemoryFeatures == rhs.externalMemoryFeatures ) &&
- ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
- ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::value,
"ExternalImageFormatPropertiesNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, externalImageFormatPropertiesNV.imageFormatProperties );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV,
- seed,
- externalImageFormatPropertiesNV.externalMemoryFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV,
- seed,
- externalImageFormatPropertiesNV.exportFromImportedHandleTypes );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV,
- seed,
- externalImageFormatPropertiesNV.compatibleHandleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalMemoryBufferCreateInfo
{
using NativeType = VkExternalMemoryBufferCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>( this );
}
- operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalMemoryBufferCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default;
#else
bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryBufferCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryBufferCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryBufferCreateInfo.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalMemoryImageCreateInfo
{
using NativeType = VkExternalMemoryImageCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalMemoryImageCreateInfo *>( this );
}
- operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalMemoryImageCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default;
#else
bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryImageCreateInfo.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalMemoryImageCreateInfoNV
{
using NativeType = VkExternalMemoryImageCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>( this );
}
- operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default;
#else
bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ExternalMemoryImageCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, externalMemoryImageCreateInfoNV.handleTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ExternalSemaphoreProperties
{
using NativeType = VkExternalSemaphoreProperties;
return *this;
}
- operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkExternalSemaphoreProperties *>( this );
}
- operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkExternalSemaphoreProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ExternalSemaphoreProperties const & ) const = default;
#else
bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
- ( compatibleHandleTypes == rhs.compatibleHandleTypes ) &&
- ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalSemaphoreProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, externalSemaphoreProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags,
- seed,
- externalSemaphoreProperties.exportFromImportedHandleTypes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, externalSemaphoreProperties.compatibleHandleTypes );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags,
- seed,
- externalSemaphoreProperties.externalSemaphoreFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FenceCreateInfo
{
using NativeType = VkFenceCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFenceCreateInfo *>( this );
}
- operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFenceCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::FenceCreateFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FenceCreateInfo const & ) const = default;
#else
bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FenceCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceCreateFlags, seed, fenceCreateInfo.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FenceGetFdInfoKHR
{
using NativeType = VkFenceGetFdInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFenceGetFdInfoKHR *>( this );
}
- operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFenceGetFdInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Fence const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fence, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FenceGetFdInfoKHR const & ) const = default;
#else
bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FenceGetFdInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetFdInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetFdInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetFdInfoKHR.fence );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetFdInfoKHR.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct FenceGetWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( this );
}
- operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Fence const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fence, handleType );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = FenceGetWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetWin32HandleInfoKHR.fence );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetWin32HandleInfoKHR.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct FilterCubicImageViewImageFormatPropertiesEXT
return *this;
}
- operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>( this );
}
- operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, filterCubic, filterCubicMinmax );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default;
#else
bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) &&
- ( filterCubicMinmax == rhs.filterCubicMinmax );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FilterCubicImageViewImageFormatPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const &
- filterCubicImageViewImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, filterCubicImageViewImageFormatPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, filterCubicImageViewImageFormatPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FormatProperties
{
using NativeType = VkFormatProperties;
return *this;
}
- operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFormatProperties *>( this );
}
- operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFormatProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FormatProperties const & ) const = default;
#else
bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
- ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FormatProperties>::value,
"FormatProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.linearTilingFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.optimalTilingFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.bufferFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FormatProperties2
{
using NativeType = VkFormatProperties2;
return *this;
}
- operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFormatProperties2 *>( this );
}
- operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFormatProperties2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::FormatProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, formatProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FormatProperties2 const & ) const = default;
#else
bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using FormatProperties2KHR = FormatProperties2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatProperties, seed, formatProperties2.formatProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FormatProperties3KHR
{
using NativeType = VkFormatProperties3KHR;
return *this;
}
- operator VkFormatProperties3KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFormatProperties3KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFormatProperties3KHR *>( this );
}
- operator VkFormatProperties3KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFormatProperties3KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFormatProperties3KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FormatProperties3KHR const & ) const = default;
#else
bool operator==( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
- ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FormatProperties3KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FormatProperties3KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::FormatProperties3KHR const & formatProperties3KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties3KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties3KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.linearTilingFeatures );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.optimalTilingFeatures );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.bufferFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FragmentShadingRateAttachmentInfoKHR
{
using NativeType = VkFragmentShadingRateAttachmentInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>( this );
}
- operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default;
#else
bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) &&
- ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FragmentShadingRateAttachmentInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const &
- fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fragmentShadingRateAttachmentInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, fragmentShadingRateAttachmentInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *,
- seed,
- fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FramebufferAttachmentImageInfo
{
using NativeType = VkFramebufferAttachmentImageInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFramebufferAttachmentImageInfo *>( this );
}
- operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFramebufferAttachmentImageInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Format * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default;
#else
bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) &&
- ( width == rhs.width ) && ( height == rhs.height ) && ( layerCount == rhs.layerCount ) &&
- ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentImageInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentImageInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, framebufferAttachmentImageInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, framebufferAttachmentImageInfo.usage );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.width );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.height );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.layerCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.viewFormatCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, framebufferAttachmentImageInfo.pViewFormats );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FramebufferAttachmentsCreateInfo
{
using NativeType = VkFramebufferAttachmentsCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>( this );
}
- operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFramebufferAttachmentsCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default;
#else
bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) &&
- ( pAttachmentImageInfos == rhs.pAttachmentImageInfos );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentsCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentsCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo *,
- seed,
- framebufferAttachmentsCreateInfo.pAttachmentImageInfos );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FramebufferCreateInfo
{
using NativeType = VkFramebufferCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFramebufferCreateInfo *>( this );
}
- operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFramebufferCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::FramebufferCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::RenderPass const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageView * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FramebufferCreateInfo const & ) const = default;
#else
bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( renderPass == rhs.renderPass ) && ( attachmentCount == rhs.attachmentCount ) &&
- ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) &&
- ( layers == rhs.layers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FramebufferCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags, seed, framebufferCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, framebufferCreateInfo.renderPass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.attachmentCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageView *, seed, framebufferCreateInfo.pAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.width );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.height );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.layers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct FramebufferMixedSamplesCombinationNV
{
using NativeType = VkFramebufferMixedSamplesCombinationNV;
return *this;
}
- operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV *>( this );
}
- operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::CoverageReductionModeNV const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default;
#else
bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( coverageReductionMode == rhs.coverageReductionMode ) &&
- ( rasterizationSamples == rhs.rasterizationSamples ) &&
- ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = FramebufferMixedSamplesCombinationNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const &
- framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferMixedSamplesCombinationNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, framebufferMixedSamplesCombinationNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::CoverageReductionModeNV, seed, framebufferMixedSamplesCombinationNV.coverageReductionMode );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, framebufferMixedSamplesCombinationNV.rasterizationSamples );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.depthStencilSamples );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.colorSamples );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct IndirectCommandsStreamNV
{
using NativeType = VkIndirectCommandsStreamNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkIndirectCommandsStreamNV *>( this );
}
- operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkIndirectCommandsStreamNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( buffer, offset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( IndirectCommandsStreamNV const & ) const = default;
#else
bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( buffer == rhs.buffer ) && ( offset == rhs.offset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>::value,
"IndirectCommandsStreamNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, indirectCommandsStreamNV.buffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, indirectCommandsStreamNV.offset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GeneratedCommandsInfoNV
{
using NativeType = VkGeneratedCommandsInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeneratedCommandsInfoNV *>( this );
}
- operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGeneratedCommandsInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ pipelineBindPoint,
+ pipeline,
+ indirectCommandsLayout,
+ streamCount,
+ pStreams,
+ sequencesCount,
+ preprocessBuffer,
+ preprocessOffset,
+ preprocessSize,
+ sequencesCountBuffer,
+ sequencesCountOffset,
+ sequencesIndexBuffer,
+ sequencesIndexOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GeneratedCommandsInfoNV const & ) const = default;
#else
bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GeneratedCommandsInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsInfoNV.pipelineBindPoint );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsInfoNV.pipeline );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, seed, generatedCommandsInfoNV.indirectCommandsLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.streamCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV *, seed, generatedCommandsInfoNV.pStreams );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.sequencesCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.preprocessBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessSize );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesCountBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesCountOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesIndexBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesIndexOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GeneratedCommandsMemoryRequirementsInfoNV
{
using NativeType = VkGeneratedCommandsMemoryRequirementsInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( this );
}
- operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default;
#else
bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
- ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) &&
- ( maxSequencesCount == rhs.maxSequencesCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GeneratedCommandsMemoryRequirementsInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const &
- generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsMemoryRequirementsInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsMemoryRequirementsInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsMemoryRequirementsInfoNV.pipeline );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV,
- seed,
- generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct VertexInputBindingDescription
{
using NativeType = VkVertexInputBindingDescription;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVertexInputBindingDescription *>( this );
}
- operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVertexInputBindingDescription *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::VertexInputRate const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( binding, stride, inputRate );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VertexInputBindingDescription const & ) const = default;
#else
bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>::value,
"VertexInputBindingDescription is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.binding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.stride );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription.inputRate );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct VertexInputAttributeDescription
{
using NativeType = VkVertexInputAttributeDescription;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVertexInputAttributeDescription *>( this );
}
- operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVertexInputAttributeDescription *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Format const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( location, binding, format, offset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VertexInputAttributeDescription const & ) const = default;
#else
bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) &&
- ( offset == rhs.offset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>::value,
"VertexInputAttributeDescription is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.location );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.binding );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription.format );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.offset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineVertexInputStateCreateInfo
{
using NativeType = VkPipelineVertexInputStateCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo *>( this );
}
- operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ vertexBindingDescriptionCount,
+ pVertexBindingDescriptions,
+ vertexAttributeDescriptionCount,
+ pVertexAttributeDescriptions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) &&
- ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) &&
- ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) &&
- ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineVertexInputStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const &
- pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags, seed, pipelineVertexInputStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription *,
- seed,
- pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription *,
- seed,
- pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineInputAssemblyStateCreateInfo
{
using NativeType = VkPipelineInputAssemblyStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo *>( this );
}
- operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::PrimitiveTopology const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, topology, primitiveRestartEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( topology == rhs.topology ) && ( primitiveRestartEnable == rhs.primitiveRestartEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineInputAssemblyStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const &
- pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInputAssemblyStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInputAssemblyStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags, seed, pipelineInputAssemblyStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PrimitiveTopology, seed, pipelineInputAssemblyStateCreateInfo.topology );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineTessellationStateCreateInfo
{
using NativeType = VkPipelineTessellationStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo *>( this );
}
- operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineTessellationStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, patchControlPoints );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( patchControlPoints == rhs.patchControlPoints );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineTessellationStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const &
- pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags, seed, pipelineTessellationStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineTessellationStateCreateInfo.patchControlPoints );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportStateCreateInfo
{
using NativeType = VkPipelineViewportStateCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportStateCreateInfo *>( this );
}
- operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Viewport * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( viewportCount == rhs.viewportCount ) && ( pViewports == rhs.pViewports ) &&
- ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags, seed, pipelineViewportStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.viewportCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Viewport *, seed, pipelineViewportStateCreateInfo.pViewports );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.scissorCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineViewportStateCreateInfo.pScissors );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationStateCreateInfo
{
using NativeType = VkPipelineRasterizationStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo *>( this );
}
- operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::PolygonMode const &,
+ VULKAN_HPP_NAMESPACE::CullModeFlags const &,
+ VULKAN_HPP_NAMESPACE::FrontFace const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ depthClampEnable,
+ rasterizerDiscardEnable,
+ polygonMode,
+ cullMode,
+ frontFace,
+ depthBiasEnable,
+ depthBiasConstantFactor,
+ depthBiasClamp,
+ depthBiasSlopeFactor,
+ lineWidth );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const &
- pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags, seed, pipelineRasterizationStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthClampEnable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PolygonMode, seed, pipelineRasterizationStateCreateInfo.polygonMode );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CullModeFlags, seed, pipelineRasterizationStateCreateInfo.cullMode );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FrontFace, seed, pipelineRasterizationStateCreateInfo.frontFace );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthBiasEnable );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasClamp );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.lineWidth );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineMultisampleStateCreateInfo
{
using NativeType = VkPipelineMultisampleStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo *>( this );
}
- operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ float const &,
+ const VULKAN_HPP_NAMESPACE::SampleMask * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ rasterizationSamples,
+ sampleShadingEnable,
+ minSampleShading,
+ pSampleMask,
+ alphaToCoverageEnable,
+ alphaToOneEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( rasterizationSamples == rhs.rasterizationSamples ) &&
- ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) &&
- ( pSampleMask == rhs.pSampleMask ) && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) &&
- ( alphaToOneEnable == rhs.alphaToOneEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineMultisampleStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const &
- pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineMultisampleStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineMultisampleStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags, seed, pipelineMultisampleStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, pipelineMultisampleStateCreateInfo.rasterizationSamples );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineMultisampleStateCreateInfo.minSampleShading );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SampleMask *, seed, pipelineMultisampleStateCreateInfo.pSampleMask );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct StencilOpState
{
using NativeType = VkStencilOpState;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkStencilOpState *>( this );
}
- operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkStencilOpState *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StencilOp const &,
+ VULKAN_HPP_NAMESPACE::StencilOp const &,
+ VULKAN_HPP_NAMESPACE::StencilOp const &,
+ VULKAN_HPP_NAMESPACE::CompareOp const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( StencilOpState const & ) const = default;
#else
bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) &&
- ( compareOp == rhs.compareOp ) && ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) &&
- ( reference == rhs.reference );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StencilOpState>::value,
"StencilOpState is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::StencilOpState>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.failOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.passOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.depthFailOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, stencilOpState.compareOp );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.compareMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.writeMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.reference );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineDepthStencilStateCreateInfo
{
using NativeType = VkPipelineDepthStencilStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo *>( this );
}
- operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::CompareOp const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::StencilOpState const &,
+ VULKAN_HPP_NAMESPACE::StencilOpState const &,
+ float const &,
+ float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ depthTestEnable,
+ depthWriteEnable,
+ depthCompareOp,
+ depthBoundsTestEnable,
+ stencilTestEnable,
+ front,
+ back,
+ minDepthBounds,
+ maxDepthBounds );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineDepthStencilStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const &
- pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDepthStencilStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDepthStencilStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags, seed, pipelineDepthStencilStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthTestEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::CompareOp, seed, pipelineDepthStencilStateCreateInfo.depthCompareOp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.front );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.back );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.minDepthBounds );
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineColorBlendAttachmentState
{
using NativeType = VkPipelineColorBlendAttachmentState;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineColorBlendAttachmentState *>( this );
}
- operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineColorBlendAttachmentState *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::BlendFactor const &,
+ VULKAN_HPP_NAMESPACE::BlendFactor const &,
+ VULKAN_HPP_NAMESPACE::BlendOp const &,
+ VULKAN_HPP_NAMESPACE::BlendFactor const &,
+ VULKAN_HPP_NAMESPACE::BlendFactor const &,
+ VULKAN_HPP_NAMESPACE::BlendOp const &,
+ VULKAN_HPP_NAMESPACE::ColorComponentFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( blendEnable,
+ srcColorBlendFactor,
+ dstColorBlendFactor,
+ colorBlendOp,
+ srcAlphaBlendFactor,
+ dstAlphaBlendFactor,
+ alphaBlendOp,
+ colorWriteMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default;
#else
bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) &&
- ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) &&
- ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) &&
- ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>::value,
"PipelineColorBlendAttachmentState is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const &
- pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAttachmentState.blendEnable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcColorBlendFactor );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstColorBlendFactor );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.colorBlendOp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.alphaBlendOp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ColorComponentFlags, seed, pipelineColorBlendAttachmentState.colorWriteMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineColorBlendStateCreateInfo
{
using NativeType = VkPipelineColorBlendStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo *>( this );
}
- operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::LogicOp const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( logicOpEnable == rhs.logicOpEnable ) && ( logicOp == rhs.logicOp ) &&
- ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
- ( blendConstants == rhs.blendConstants );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineColorBlendStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const &
- pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags, seed, pipelineColorBlendStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendStateCreateInfo.logicOpEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LogicOp, seed, pipelineColorBlendStateCreateInfo.logicOp );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorBlendStateCreateInfo.attachmentCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState *,
- seed,
- pipelineColorBlendStateCreateInfo.pAttachments );
- for ( size_t i = 0; i < 4; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, pipelineColorBlendStateCreateInfo.blendConstants[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineDynamicStateCreateInfo
{
using NativeType = VkPipelineDynamicStateCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo *>( this );
}
- operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineDynamicStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DynamicState * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( dynamicStateCount == rhs.dynamicStateCount ) && ( pDynamicStates == rhs.pDynamicStates );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineDynamicStateCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDynamicStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDynamicStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags, seed, pipelineDynamicStateCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDynamicStateCreateInfo.dynamicStateCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DynamicState *, seed, pipelineDynamicStateCreateInfo.pDynamicStates );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GraphicsPipelineCreateInfo
{
using NativeType = VkGraphicsPipelineCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( this );
}
- operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGraphicsPipelineCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo * const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+ VULKAN_HPP_NAMESPACE::RenderPass const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ stageCount,
+ pStages,
+ pVertexInputState,
+ pInputAssemblyState,
+ pTessellationState,
+ pViewportState,
+ pRasterizationState,
+ pMultisampleState,
+ pDepthStencilState,
+ pColorBlendState,
+ pDynamicState,
+ layout,
+ renderPass,
+ subpass,
+ basePipelineHandle,
+ basePipelineIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default;
#else
bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
- ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) &&
- ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) &&
- ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) &&
- ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) &&
- ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) &&
- ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) &&
- ( basePipelineIndex == rhs.basePipelineIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GraphicsPipelineCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, graphicsPipelineCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.stageCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsPipelineCreateInfo.pStages );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pVertexInputState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pInputAssemblyState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pTessellationState );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo *, seed, graphicsPipelineCreateInfo.pViewportState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pRasterizationState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pMultisampleState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pDepthStencilState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo *,
- seed,
- graphicsPipelineCreateInfo.pColorBlendState );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *, seed, graphicsPipelineCreateInfo.pDynamicState );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, graphicsPipelineCreateInfo.layout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, graphicsPipelineCreateInfo.renderPass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.subpass );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, graphicsPipelineCreateInfo.basePipelineHandle );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, graphicsPipelineCreateInfo.basePipelineIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GraphicsShaderGroupCreateInfoNV
{
using NativeType = VkGraphicsShaderGroupCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV *>( this );
}
- operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default;
#else
bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) &&
- ( pStages == rhs.pStages ) && ( pVertexInputState == rhs.pVertexInputState ) &&
- ( pTessellationState == rhs.pTessellationState );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GraphicsShaderGroupCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsShaderGroupCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsShaderGroupCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsShaderGroupCreateInfoNV.stageCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsShaderGroupCreateInfoNV.pStages );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *,
- seed,
- graphicsShaderGroupCreateInfoNV.pVertexInputState );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *,
- seed,
- graphicsShaderGroupCreateInfoNV.pTessellationState );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct GraphicsPipelineShaderGroupsCreateInfoNV
{
using NativeType = VkGraphicsPipelineShaderGroupsCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV *>( this );
}
- operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Pipeline * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default;
#else
bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) &&
- ( pGroups == rhs.pGroups ) && ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = GraphicsPipelineShaderGroupsCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const &
- graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineShaderGroupsCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV *,
- seed,
- graphicsPipelineShaderGroupsCreateInfoNV.pGroups );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Pipeline *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct XYColorEXT
{
using NativeType = VkXYColorEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkXYColorEXT *>( this );
}
- operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkXYColorEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( XYColorEXT const & ) const = default;
#else
bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::XYColorEXT>::value,
"XYColorEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.x );
- VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.y );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct HdrMetadataEXT
{
using NativeType = VkHdrMetadataEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkHdrMetadataEXT *>( this );
}
- operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkHdrMetadataEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+ VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+ VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+ VULKAN_HPP_NAMESPACE::XYColorEXT const &,
+ float const &,
+ float const &,
+ float const &,
+ float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ displayPrimaryRed,
+ displayPrimaryGreen,
+ displayPrimaryBlue,
+ whitePoint,
+ maxLuminance,
+ minLuminance,
+ maxContentLightLevel,
+ maxFrameAverageLightLevel );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( HdrMetadataEXT const & ) const = default;
#else
bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = HdrMetadataEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, hdrMetadataEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, hdrMetadataEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryRed );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryGreen );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryBlue );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.whitePoint );
- VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxLuminance );
- VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.minLuminance );
- VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxContentLightLevel );
- VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxFrameAverageLightLevel );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct HeadlessSurfaceCreateInfoEXT
{
using NativeType = VkHeadlessSurfaceCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( this );
}
- operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default;
#else
bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = HeadlessSurfaceCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, headlessSurfaceCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, headlessSurfaceCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT, seed, headlessSurfaceCreateInfoEXT.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_IOS_MVK )
struct IOSSurfaceCreateInfoMVK
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( this );
}
- operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK const &,
+ const void * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pView );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default;
# else
bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = IOSSurfaceCreateInfoMVK;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, iOSSurfaceCreateInfoMVK.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK, seed, iOSSurfaceCreateInfoMVK.flags );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pView );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_IOS_MVK*/
struct ImageBlit
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageBlit *>( this );
}
- operator VkImageBlit &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageBlit &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageBlit *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageBlit const & ) const = default;
#else
bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) &&
- ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageBlit>::value,
"ImageBlit is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageBlit>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.srcSubresource );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.srcOffsets[i] );
- }
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.dstSubresource );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.dstOffsets[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_FUCHSIA )
struct ImageFormatConstraintsInfoFUCHSIA
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIA *>( this );
}
- operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageCreateInfo const &,
+ VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA const &,
+ uint64_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ imageCreateInfo,
+ requiredFormatFeatures,
+ flags,
+ sysmemPixelFormat,
+ colorSpaceCount,
+ pColorSpaces );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default;
# else
bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) &&
- ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) &&
- ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( colorSpaceCount == rhs.colorSpaceCount ) &&
- ( pColorSpaces == rhs.pColorSpaces );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImageFormatConstraintsInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const &
- imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatConstraintsInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatConstraintsInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageCreateInfo, seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA, seed, imageFormatConstraintsInfoFUCHSIA.flags );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA *, seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( this );
}
- operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageConstraintsInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA * const &,
+ VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &,
+ VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default;
# else
bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( formatConstraintsCount == rhs.formatConstraintsCount ) &&
- ( pFormatConstraints == rhs.pFormatConstraints ) &&
- ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImageConstraintsInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageConstraintsInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageConstraintsInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA *,
- seed,
- imageConstraintsInfoFUCHSIA.pFormatConstraints );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA,
- seed,
- imageConstraintsInfoFUCHSIA.bufferCollectionConstraints );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA, seed, imageConstraintsInfoFUCHSIA.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct ImageCopy
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageCopy *>( this );
}
- operator VkImageCopy &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageCopy &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageCopy *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageCopy const & ) const = default;
#else
bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
- ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageCopy>::value,
"ImageCopy is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageCopy>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.srcSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.srcOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.dstSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.dstOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy.extent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubresourceLayout
{
using NativeType = VkSubresourceLayout;
return *this;
}
- operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubresourceLayout *>( this );
}
- operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubresourceLayout *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( offset, size, rowPitch, arrayPitch, depthPitch );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubresourceLayout const & ) const = default;
#else
bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) &&
- ( arrayPitch == rhs.arrayPitch ) && ( depthPitch == rhs.depthPitch );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubresourceLayout>::value,
"SubresourceLayout is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.rowPitch );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.arrayPitch );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.depthPitch );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageDrmFormatModifierExplicitCreateInfoEXT
{
using NativeType = VkImageDrmFormatModifierExplicitCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>( this );
}
- operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint64_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SubresourceLayout * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default;
#else
bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
- ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
- ( pPlaneLayouts == rhs.pPlaneLayouts );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageDrmFormatModifierExplicitCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const &
- imageDrmFormatModifierExplicitCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubresourceLayout *,
- seed,
- imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageDrmFormatModifierListCreateInfoEXT
{
using NativeType = VkImageDrmFormatModifierListCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>( this );
}
- operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint64_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default;
#else
bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
- ( pDrmFormatModifiers == rhs.pDrmFormatModifiers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageDrmFormatModifierListCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const &
- imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierListCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierListCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageDrmFormatModifierPropertiesEXT
{
using NativeType = VkImageDrmFormatModifierPropertiesEXT;
return *this;
}
- operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT *>( this );
}
- operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, drmFormatModifier );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default;
#else
bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageDrmFormatModifierPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const &
- imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, imageDrmFormatModifierPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageFormatListCreateInfo
{
using NativeType = VkImageFormatListCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageFormatListCreateInfo *>( this );
}
- operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageFormatListCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Format * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, viewFormatCount, pViewFormats );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageFormatListCreateInfo const & ) const = default;
#else
bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) &&
- ( pViewFormats == rhs.pViewFormats );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatListCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatListCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatListCreateInfo.viewFormatCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, imageFormatListCreateInfo.pViewFormats );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageFormatProperties2
{
using NativeType = VkImageFormatProperties2;
return *this;
}
- operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageFormatProperties2 *>( this );
}
- operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageFormatProperties2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ImageFormatProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageFormatProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageFormatProperties2 const & ) const = default;
#else
bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImageFormatProperties2KHR = ImageFormatProperties2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatProperties2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, imageFormatProperties2.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, imageFormatProperties2.imageFormatProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageMemoryBarrier
{
using NativeType = VkImageMemoryBarrier;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageMemoryBarrier *>( this );
}
- operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageMemoryBarrier *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ srcAccessMask,
+ dstAccessMask,
+ oldLayout,
+ newLayout,
+ srcQueueFamilyIndex,
+ dstQueueFamilyIndex,
+ image,
+ subresourceRange );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageMemoryBarrier const & ) const = default;
#else
bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
- ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
- ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
- ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) &&
- ( subresourceRange == rhs.subresourceRange );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageMemoryBarrier;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.dstAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.oldLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.newLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.srcQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.dstQueueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier.image );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier.subresourceRange );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageMemoryRequirementsInfo2
{
using NativeType = VkImageMemoryRequirementsInfo2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( this );
}
- operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageMemoryRequirementsInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Image const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, image );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default;
#else
bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryRequirementsInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryRequirementsInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryRequirementsInfo2.image );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_FUCHSIA )
struct ImagePipeSurfaceCreateInfoFUCHSIA
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( this );
}
- operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA const &,
+ zx_handle_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, imagePipeHandle );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & ) const = default;
# else
bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImagePipeSurfaceCreateInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &
- imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePipeSurfaceCreateInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA, seed, imagePipeSurfaceCreateInfoFUCHSIA.flags );
- VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct ImagePlaneMemoryRequirementsInfo
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>( this );
}
- operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, planeAspect );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default;
#else
bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePlaneMemoryRequirementsInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePlaneMemoryRequirementsInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, imagePlaneMemoryRequirementsInfo.planeAspect );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageResolve
{
using NativeType = VkImageResolve;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageResolve *>( this );
}
- operator VkImageResolve &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageResolve &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageResolve *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageResolve const & ) const = default;
#else
bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
- ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageResolve>::value,
"ImageResolve is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageResolve>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.srcSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.srcOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.dstSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.dstOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve.extent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageResolve2KHR
{
using NativeType = VkImageResolve2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageResolve2KHR *>( this );
}
- operator VkImageResolve2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageResolve2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageResolve2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
+ VULKAN_HPP_NAMESPACE::Offset3D const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageResolve2KHR const & ) const = default;
#else
bool operator==( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
- ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) &&
- ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageResolve2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageResolve2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2KHR const & imageResolve2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageResolve2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageResolve2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.srcSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.srcOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.dstSubresource );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.dstOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve2KHR.extent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageSparseMemoryRequirementsInfo2
{
using NativeType = VkImageSparseMemoryRequirementsInfo2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( this );
}
- operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Image const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, image );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default;
#else
bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const &
- imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSparseMemoryRequirementsInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSparseMemoryRequirementsInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageSparseMemoryRequirementsInfo2.image );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageStencilUsageCreateInfo
{
using NativeType = VkImageStencilUsageCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageStencilUsageCreateInfo *>( this );
}
- operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageStencilUsageCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stencilUsage );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default;
#else
bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageStencilUsageCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageStencilUsageCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageStencilUsageCreateInfo.stencilUsage );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageSwapchainCreateInfoKHR
{
using NativeType = VkImageSwapchainCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>( this );
}
- operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageSwapchainCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SwapchainKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchain );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default;
#else
bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageSwapchainCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSwapchainCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSwapchainCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, imageSwapchainCreateInfoKHR.swapchain );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageViewASTCDecodeModeEXT
{
using NativeType = VkImageViewASTCDecodeModeEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>( this );
}
- operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewASTCDecodeModeEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Format const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, decodeMode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default;
#else
bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageViewASTCDecodeModeEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewASTCDecodeModeEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewASTCDecodeModeEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewASTCDecodeModeEXT.decodeMode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageViewAddressPropertiesNVX
{
using NativeType = VkImageViewAddressPropertiesNVX;
return *this;
}
- operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewAddressPropertiesNVX *>( this );
}
- operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewAddressPropertiesNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceAddress const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceAddress, size );
+ }
+
#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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageViewAddressPropertiesNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewAddressPropertiesNVX.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, imageViewAddressPropertiesNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, imageViewAddressPropertiesNVX.deviceAddress );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageViewAddressPropertiesNVX.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageViewCreateInfo
{
using NativeType = VkImageViewCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewCreateInfo *>( this );
}
- operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageViewCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageViewType const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+ VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageViewCreateInfo const & ) const = default;
#else
bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) &&
- ( viewType == rhs.viewType ) && ( format == rhs.format ) && ( components == rhs.components ) &&
- ( subresourceRange == rhs.subresourceRange );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageViewCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags, seed, imageViewCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageViewCreateInfo.image );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewType, seed, imageViewCreateInfo.viewType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewCreateInfo.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, seed, imageViewCreateInfo.components );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageViewCreateInfo.subresourceRange );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageViewHandleInfoNVX
{
using NativeType = VkImageViewHandleInfoNVX;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewHandleInfoNVX *>( this );
}
- operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewHandleInfoNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &,
+ VULKAN_HPP_NAMESPACE::DescriptorType const &,
+ VULKAN_HPP_NAMESPACE::Sampler const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageView, descriptorType, sampler );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageViewHandleInfoNVX const & ) const = default;
#else
bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
- ( descriptorType == rhs.descriptorType ) && ( sampler == rhs.sampler );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageViewHandleInfoNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewHandleInfoNVX.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewHandleInfoNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, imageViewHandleInfoNVX.imageView );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, imageViewHandleInfoNVX.descriptorType );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, imageViewHandleInfoNVX.sampler );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageViewMinLodCreateInfoEXT
{
using NativeType = VkImageViewMinLodCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewMinLodCreateInfoEXT *>( this );
}
- operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewMinLodCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, minLod );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default;
#else
bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImageViewMinLodCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewMinLodCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewMinLodCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( float, seed, imageViewMinLodCreateInfoEXT.minLod );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImageViewUsageCreateInfo
{
using NativeType = VkImageViewUsageCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImageViewUsageCreateInfo *>( this );
}
- operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImageViewUsageCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, usage );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageViewUsageCreateInfo const & ) const = default;
#else
bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewUsageCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewUsageCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageViewUsageCreateInfo.usage );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
struct ImportAndroidHardwareBufferInfoANDROID
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>( this );
}
- operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, struct AHardwareBuffer * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, buffer );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default;
# else
bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportAndroidHardwareBufferInfoANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const &
- importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importAndroidHardwareBufferInfoANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importAndroidHardwareBufferInfoANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE( struct AHardwareBuffer *, seed, importAndroidHardwareBufferInfoANDROID.buffer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
struct ImportFenceFdInfoKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportFenceFdInfoKHR *>( this );
}
- operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportFenceFdInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Fence const &,
+ VULKAN_HPP_NAMESPACE::FenceImportFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &,
+ int const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fence, flags, handleType, fd );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportFenceFdInfoKHR const & ) const = default;
#else
bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) &&
- ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImportFenceFdInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceFdInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceFdInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceFdInfoKHR.fence );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceFdInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceFdInfoKHR.handleType );
- VULKAN_HPP_HASH_COMBINE( int, seed, importFenceFdInfoKHR.fd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ImportFenceWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( this );
}
- operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Fence const &,
+ VULKAN_HPP_NAMESPACE::FenceImportFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &,
+ HANDLE const &,
+ LPCWSTR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fence, flags, handleType, handle, name );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) &&
- ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportFenceWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceWin32HandleInfoKHR.fence );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceWin32HandleInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceWin32HandleInfoKHR.handleType );
- VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importFenceWin32HandleInfoKHR.handle );
- VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importFenceWin32HandleInfoKHR.name );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA *>( this );
}
- operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, collection, index );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default;
# else
bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
- ( index == rhs.index );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportMemoryBufferCollectionFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const &
- importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryBufferCollectionFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryBufferCollectionFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, importMemoryBufferCollectionFUCHSIA.collection );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, importMemoryBufferCollectionFUCHSIA.index );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct ImportMemoryFdInfoKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryFdInfoKHR *>( this );
}
- operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryFdInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+ int const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType, fd );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default;
#else
bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImportMemoryFdInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryFdInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryFdInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryFdInfoKHR.handleType );
- VULKAN_HPP_HASH_COMBINE( int, seed, importMemoryFdInfoKHR.fd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ImportMemoryHostPointerInfoEXT
{
using NativeType = VkImportMemoryHostPointerInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>( this );
}
- operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType, pHostPointer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default;
#else
bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
- ( pHostPointer == rhs.pHostPointer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImportMemoryHostPointerInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryHostPointerInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryHostPointerInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryHostPointerInfoEXT.handleType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, importMemoryHostPointerInfoEXT.pHostPointer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ImportMemoryWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>( this );
}
- operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+ HANDLE const &,
+ LPCWSTR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType, handle, name );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
- ( handle == rhs.handle ) && ( name == rhs.name );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportMemoryWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryWin32HandleInfoKHR.handleType );
- VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoKHR.handle );
- VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importMemoryWin32HandleInfoKHR.name );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>( this );
}
- operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &,
+ HANDLE const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType, handle );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default;
# else
bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
- ( handle == rhs.handle );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportMemoryWin32HandleInfoNV;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, importMemoryWin32HandleInfoNV.handleType );
- VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoNV.handle );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>( this );
}
- operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
+ zx_handle_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType, handle );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & ) const = default;
# else
bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
- ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportMemoryZirconHandleInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const &
- importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryZirconHandleInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryZirconHandleInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryZirconHandleInfoFUCHSIA.handleType );
- VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importMemoryZirconHandleInfoFUCHSIA.handle );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct ImportSemaphoreFdInfoKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( this );
}
- operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportSemaphoreFdInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
+ int const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, flags, handleType, fd );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default;
#else
bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ImportSemaphoreFdInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreFdInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreFdInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreFdInfoKHR.semaphore );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreFdInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreFdInfoKHR.handleType );
- VULKAN_HPP_HASH_COMBINE( int, seed, importSemaphoreFdInfoKHR.fd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ImportSemaphoreWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( this );
}
- operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
+ HANDLE const &,
+ LPCWSTR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, flags, handleType, handle, name );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) &&
- ( name == rhs.name );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportSemaphoreWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const &
- importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreWin32HandleInfoKHR.semaphore );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreWin32HandleInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreWin32HandleInfoKHR.handleType );
- VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importSemaphoreWin32HandleInfoKHR.handle );
- VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importSemaphoreWin32HandleInfoKHR.name );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( this );
}
- operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
+ zx_handle_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & ) const = default;
# else
bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
- ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ImportSemaphoreZirconHandleInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const &
- importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreZirconHandleInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreZirconHandleInfoFUCHSIA.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits,
- seed,
- importSemaphoreZirconHandleInfoFUCHSIA.handleType );
- VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct IndirectCommandsLayoutTokenNV
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNV *>( this );
}
- operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkIndirectCommandsLayoutTokenNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::IndexType * const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ tokenType,
+ stream,
+ offset,
+ vertexBindingUnit,
+ vertexDynamicStride,
+ pushconstantPipelineLayout,
+ pushconstantShaderStageFlags,
+ pushconstantOffset,
+ pushconstantSize,
+ indirectStateFlags,
+ indexTypeCount,
+ pIndexTypes,
+ pIndexTypeValues );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default;
#else
bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = IndirectCommandsLayoutTokenNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutTokenNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutTokenNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV, seed, indirectCommandsLayoutTokenNV.tokenType );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.stream );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.offset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.vertexBindingUnit );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, indirectCommandsLayoutTokenNV.vertexDynamicStride );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineLayout, seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV, seed, indirectCommandsLayoutTokenNV.indirectStateFlags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.indexTypeCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::IndexType *, seed, indirectCommandsLayoutTokenNV.pIndexTypes );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutTokenNV.pIndexTypeValues );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct IndirectCommandsLayoutCreateInfoNV
{
using NativeType = VkIndirectCommandsLayoutCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( this );
}
- operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default;
#else
bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( tokenCount == rhs.tokenCount ) &&
- ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) &&
- ( pStreamStrides == rhs.pStreamStrides );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = IndirectCommandsLayoutCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &
- indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV, seed, indirectCommandsLayoutCreateInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.tokenCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV *, seed, indirectCommandsLayoutCreateInfoNV.pTokens );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.streamCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct InitializePerformanceApiInfoINTEL
{
using NativeType = VkInitializePerformanceApiInfoINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( this );
}
- operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkInitializePerformanceApiInfoINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pUserData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default;
#else
bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = InitializePerformanceApiInfoINTEL;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const &
- initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, initializePerformanceApiInfoINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, initializePerformanceApiInfoINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE( void *, seed, initializePerformanceApiInfoINTEL.pUserData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct InputAttachmentAspectReference
{
using NativeType = VkInputAttachmentAspectReference;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkInputAttachmentAspectReference *>( this );
}
- operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkInputAttachmentAspectReference *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ImageAspectFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( subpass, inputAttachmentIndex, aspectMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( InputAttachmentAspectReference const & ) const = default;
#else
bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) &&
- ( aspectMask == rhs.aspectMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
"InputAttachmentAspectReference is not nothrow_move_constructible!" );
using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.subpass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.inputAttachmentIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, inputAttachmentAspectReference.aspectMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct InstanceCreateInfo
{
using NativeType = VkInstanceCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkInstanceCreateInfo *>( this );
}
- operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkInstanceCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::InstanceCreateFlags const &,
+ const VULKAN_HPP_NAMESPACE::ApplicationInfo * const &,
+ uint32_t const &,
+ const char * const * const &,
+ uint32_t const &,
+ const char * const * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ pApplicationInfo,
+ enabledLayerCount,
+ ppEnabledLayerNames,
+ enabledExtensionCount,
+ ppEnabledExtensionNames );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( InstanceCreateInfo const & ) const = default;
#else
bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pApplicationInfo == rhs.pApplicationInfo ) && ( enabledLayerCount == rhs.enabledLayerCount ) &&
- ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) &&
- ( enabledExtensionCount == rhs.enabledExtensionCount ) &&
- ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = InstanceCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, instanceCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, instanceCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::InstanceCreateFlags, seed, instanceCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ApplicationInfo *, seed, instanceCreateInfo.pApplicationInfo );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledLayerCount );
- VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledLayerNames );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledExtensionCount );
- VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledExtensionNames );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct LayerProperties
{
using NativeType = VkLayerProperties;
return *this;
}
- operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkLayerProperties *>( this );
}
- operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkLayerProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( layerName, specVersion, implementationVersion, description );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( LayerProperties const & ) const = default;
#else
bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) &&
- ( implementationVersion == rhs.implementationVersion ) && ( description == rhs.description );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LayerProperties>::value,
"LayerProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::LayerProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.layerName[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.specVersion );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.implementationVersion );
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.description[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_MACOS_MVK )
struct MacOSSurfaceCreateInfoMVK
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( this );
}
- operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK const &,
+ const void * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pView );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default;
# else
bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MacOSSurfaceCreateInfoMVK;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, macOSSurfaceCreateInfoMVK.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK, seed, macOSSurfaceCreateInfoMVK.flags );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pView );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
struct MappedMemoryRange
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMappedMemoryRange *>( this );
}
- operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMappedMemoryRange *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory, offset, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MappedMemoryRange const & ) const = default;
#else
bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) &&
- ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MappedMemoryRange;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mappedMemoryRange.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, mappedMemoryRange.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, mappedMemoryRange.memory );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryAllocateFlagsInfo
{
using NativeType = VkMemoryAllocateFlagsInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryAllocateFlagsInfo *>( this );
}
- operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryAllocateFlagsInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::MemoryAllocateFlags const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, deviceMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default;
#else
bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( deviceMask == rhs.deviceMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateFlagsInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateFlagsInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags, seed, memoryAllocateFlagsInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateFlagsInfo.deviceMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryAllocateInfo
{
using NativeType = VkMemoryAllocateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryAllocateInfo *>( this );
}
- operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, allocationSize, memoryTypeIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryAllocateInfo const & ) const = default;
#else
bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) &&
- ( memoryTypeIndex == rhs.memoryTypeIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryAllocateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryAllocateInfo.allocationSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateInfo.memoryTypeIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryBarrier
{
using NativeType = VkMemoryBarrier;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryBarrier *>( this );
}
- operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryBarrier *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcAccessMask, dstAccessMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryBarrier const & ) const = default;
#else
bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
- ( dstAccessMask == rhs.dstAccessMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryBarrier;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.dstAccessMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryDedicatedAllocateInfo
{
using NativeType = VkMemoryDedicatedAllocateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>( this );
}
- operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryDedicatedAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, image, buffer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default;
#else
bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryDedicatedAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, memoryDedicatedAllocateInfo.image );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, memoryDedicatedAllocateInfo.buffer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryDedicatedRequirements
{
using NativeType = VkMemoryDedicatedRequirements;
return *this;
}
- operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryDedicatedRequirements *>( this );
}
- operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryDedicatedRequirements *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryDedicatedRequirements const & ) const = default;
#else
bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) &&
- ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedRequirements.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, memoryDedicatedRequirements.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.prefersDedicatedAllocation );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.requiresDedicatedAllocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryFdPropertiesKHR
{
using NativeType = VkMemoryFdPropertiesKHR;
return *this;
}
- operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryFdPropertiesKHR *>( this );
}
- operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryFdPropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryTypeBits );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryFdPropertiesKHR const & ) const = default;
#else
bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryFdPropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryFdPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, memoryFdPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryFdPropertiesKHR.memoryTypeBits );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
struct MemoryGetAndroidHardwareBufferInfoANDROID
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( this );
}
- operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default;
# else
bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MemoryGetAndroidHardwareBufferInfoANDROID;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const &
- memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetAndroidHardwareBufferInfoANDROID.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetAndroidHardwareBufferInfoANDROID.memory );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
struct MemoryGetFdInfoKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryGetFdInfoKHR *>( this );
}
- operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryGetFdInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryGetFdInfoKHR const & ) const = default;
#else
bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryGetFdInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetFdInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetFdInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetFdInfoKHR.memory );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetFdInfoKHR.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryGetRemoteAddressInfoNV
{
using NativeType = VkMemoryGetRemoteAddressInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( this );
}
- operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryGetRemoteAddressInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default;
#else
bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryGetRemoteAddressInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetRemoteAddressInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetRemoteAddressInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetRemoteAddressInfoNV.memory );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetRemoteAddressInfoNV.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct MemoryGetWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( this );
}
- operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory, handleType );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MemoryGetWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetWin32HandleInfoKHR.memory );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetWin32HandleInfoKHR.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( this );
}
- operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memory, handleType );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default;
# else
bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MemoryGetZirconHandleInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetZirconHandleInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetZirconHandleInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetZirconHandleInfoFUCHSIA.memory );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetZirconHandleInfoFUCHSIA.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct MemoryHeap
return *this;
}
- operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryHeap *>( this );
}
- operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryHeap *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &, VULKAN_HPP_NAMESPACE::MemoryHeapFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( size, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryHeap const & ) const = default;
#else
bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( size == rhs.size ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryHeap>::value,
"MemoryHeap is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryHeap.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeapFlags, seed, memoryHeap.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryHostPointerPropertiesEXT
{
using NativeType = VkMemoryHostPointerPropertiesEXT;
return *this;
}
- operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT *>( this );
}
- operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryTypeBits );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default;
#else
bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryHostPointerPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryHostPointerPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, memoryHostPointerPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryHostPointerPropertiesEXT.memoryTypeBits );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryOpaqueCaptureAddressAllocateInfo
{
using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo *>( this );
}
- operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, opaqueCaptureAddress );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default;
#else
bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const &
- memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryOpaqueCaptureAddressAllocateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryOpaqueCaptureAddressAllocateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryPriorityAllocateInfoEXT
{
using NativeType = VkMemoryPriorityAllocateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>( this );
}
- operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, priority );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default;
#else
bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MemoryPriorityAllocateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryPriorityAllocateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryPriorityAllocateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( float, seed, memoryPriorityAllocateInfoEXT.priority );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryRequirements
{
using NativeType = VkMemoryRequirements;
return *this;
}
- operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryRequirements *>( this );
}
- operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryRequirements *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &, VULKAN_HPP_NAMESPACE::DeviceSize const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( size, alignment, memoryTypeBits );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryRequirements const & ) const = default;
#else
bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryRequirements>::value,
"MemoryRequirements is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.size );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.alignment );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryRequirements.memoryTypeBits );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryRequirements2
{
using NativeType = VkMemoryRequirements2;
return *this;
}
- operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryRequirements2 *>( this );
}
- operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryRequirements2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::MemoryRequirements const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryRequirements );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryRequirements2 const & ) const = default;
#else
bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using MemoryRequirements2KHR = MemoryRequirements2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryRequirements2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, memoryRequirements2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryRequirements, seed, memoryRequirements2.memoryRequirements );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MemoryType
{
using NativeType = VkMemoryType;
return *this;
}
- operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryType *>( this );
}
- operator VkMemoryType &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryType &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryType *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::MemoryPropertyFlags const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( propertyFlags, heapIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryType const & ) const = default;
#else
bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryType>::value,
"MemoryType is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryType>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags, seed, memoryType.propertyFlags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryType.heapIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct MemoryWin32HandlePropertiesKHR
{
return *this;
}
- operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR *>( this );
}
- operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryTypeBits );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default;
# else
bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MemoryWin32HandlePropertiesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryWin32HandlePropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, memoryWin32HandlePropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryWin32HandlePropertiesKHR.memoryTypeBits );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
return *this;
}
- operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryZirconHandlePropertiesFUCHSIA *>( this );
}
- operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryTypeBits );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default;
# else
bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MemoryZirconHandlePropertiesFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const &
- memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryZirconHandlePropertiesFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, memoryZirconHandlePropertiesFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( this );
}
- operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMetalSurfaceCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT const &,
+ const CAMetalLayer * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pLayer );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default;
# else
bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = MetalSurfaceCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, metalSurfaceCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, metalSurfaceCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT, seed, metalSurfaceCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( const CAMetalLayer *, seed, metalSurfaceCreateInfoEXT.pLayer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_METAL_EXT*/
struct MultiDrawIndexedInfoEXT
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( this );
}
- operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMultiDrawIndexedInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( firstIndex, indexCount, vertexOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default;
#else
bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) &&
- ( vertexOffset == rhs.vertexOffset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>::value,
"MultiDrawIndexedInfoEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.firstIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.indexCount );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, multiDrawIndexedInfoEXT.vertexOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MultiDrawInfoEXT
{
using NativeType = VkMultiDrawInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMultiDrawInfoEXT *>( this );
}
- operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMultiDrawInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( firstVertex, vertexCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MultiDrawInfoEXT const & ) const = default;
#else
bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>::value,
"MultiDrawInfoEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.firstVertex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.vertexCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MultisamplePropertiesEXT
{
using NativeType = VkMultisamplePropertiesEXT;
return *this;
}
- operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMultisamplePropertiesEXT *>( this );
}
- operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMultisamplePropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxSampleLocationGridSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MultisamplePropertiesEXT const & ) const = default;
#else
bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MultisamplePropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multisamplePropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, multisamplePropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, multisamplePropertiesEXT.maxSampleLocationGridSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MultiviewPerViewAttributesInfoNVX
{
using NativeType = VkMultiviewPerViewAttributesInfoNVX;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX *>( this );
}
- operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default;
#else
bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) &&
- ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MultiviewPerViewAttributesInfoNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const &
- multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multiviewPerViewAttributesInfoNVX.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, multiviewPerViewAttributesInfoNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MutableDescriptorTypeListVALVE
{
using NativeType = VkMutableDescriptorTypeListVALVE;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMutableDescriptorTypeListVALVE *>( this );
}
- operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMutableDescriptorTypeListVALVE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::DescriptorType * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( descriptorTypeCount, pDescriptorTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default;
#else
bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>::value,
"MutableDescriptorTypeListVALVE is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const & mutableDescriptorTypeListVALVE )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeListVALVE.descriptorTypeCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DescriptorType *, seed, mutableDescriptorTypeListVALVE.pDescriptorTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct MutableDescriptorTypeCreateInfoVALVE
{
using NativeType = VkMutableDescriptorTypeCreateInfoVALVE;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE *>( this );
}
- operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default;
#else
bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) &&
- ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = MutableDescriptorTypeCreateInfoVALVE;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const &
- mutableDescriptorTypeCreateInfoVALVE ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mutableDescriptorTypeCreateInfoVALVE.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, mutableDescriptorTypeCreateInfoVALVE.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeCreateInfoVALVE.mutableDescriptorTypeListCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE *,
- seed,
- mutableDescriptorTypeCreateInfoVALVE.pMutableDescriptorTypeLists );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PastPresentationTimingGOOGLE
{
using NativeType = VkPastPresentationTimingGOOGLE;
return *this;
}
- operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPastPresentationTimingGOOGLE *>( this );
}
- operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPastPresentationTimingGOOGLE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint64_t const &, uint64_t const &, uint64_t const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default;
#else
bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) &&
- ( actualPresentTime == rhs.actualPresentTime ) && ( earliestPresentTime == rhs.earliestPresentTime ) &&
- ( presentMargin == rhs.presentMargin );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
"PastPresentationTimingGOOGLE is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pastPresentationTimingGOOGLE.presentID );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.desiredPresentTime );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.actualPresentTime );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.earliestPresentTime );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.presentMargin );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PerformanceConfigurationAcquireInfoINTEL
{
using NativeType = VkPerformanceConfigurationAcquireInfoINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( this );
}
- operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, type );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default;
#else
bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceConfigurationAcquireInfoINTEL;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &
- performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, performanceConfigurationAcquireInfoINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceConfigurationAcquireInfoINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL, seed, performanceConfigurationAcquireInfoINTEL.type );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PerformanceCounterDescriptionKHR
{
using NativeType = VkPerformanceCounterDescriptionKHR;
return *this;
}
- operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceCounterDescriptionKHR *>( this );
}
- operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, name, category, description );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default;
#else
bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) &&
- ( category == rhs.category ) && ( description == rhs.description );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceCounterDescriptionKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterDescriptionKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterDescriptionKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR, seed, performanceCounterDescriptionKHR.flags );
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.name[i] );
- }
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.category[i] );
- }
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.description[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PerformanceCounterKHR
{
using NativeType = VkPerformanceCounterKHR;
return *this;
}
- operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceCounterKHR *>( this );
}
- operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceCounterKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR const &,
+ VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR const &,
+ VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, unit, scope, storage, uuid );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceCounterKHR const & ) const = default;
#else
bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) &&
- ( storage == rhs.storage ) && ( uuid == rhs.uuid );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceCounterKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR, seed, performanceCounterKHR.unit );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR, seed, performanceCounterKHR.scope );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR, seed, performanceCounterKHR.storage );
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, performanceCounterKHR.uuid[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union PerformanceCounterResultKHR
{
using NativeType = VkPerformanceCounterResultKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( this );
}
- operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceMarkerInfoINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, marker );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default;
#else
bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceMarkerInfoINTEL;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceMarkerInfoINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceMarkerInfoINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceMarkerInfoINTEL.marker );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PerformanceOverrideInfoINTEL
{
using NativeType = VkPerformanceOverrideInfoINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( this );
}
- operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceOverrideInfoINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, type, enable, parameter );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default;
#else
bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) &&
- ( parameter == rhs.parameter );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceOverrideInfoINTEL;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceOverrideInfoINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceOverrideInfoINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL, seed, performanceOverrideInfoINTEL.type );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, performanceOverrideInfoINTEL.enable );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceOverrideInfoINTEL.parameter );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PerformanceQuerySubmitInfoKHR
{
using NativeType = VkPerformanceQuerySubmitInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR *>( this );
}
- operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, counterPassIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default;
#else
bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceQuerySubmitInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceQuerySubmitInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceQuerySubmitInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceQuerySubmitInfoKHR.counterPassIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PerformanceStreamMarkerInfoINTEL
{
using NativeType = VkPerformanceStreamMarkerInfoINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( this );
}
- operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, marker );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default;
#else
bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PerformanceStreamMarkerInfoINTEL;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceStreamMarkerInfoINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceStreamMarkerInfoINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceStreamMarkerInfoINTEL.marker );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union PerformanceValueDataINTEL
{
using NativeType = VkPerformanceValueDataINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPerformanceValueINTEL *>( this );
}
- operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPerformanceValueINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL const &,
+ VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( type, data );
+ }
+
public:
VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32;
VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>( this );
}
- operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ storageBuffer16BitAccess,
+ uniformAndStorageBuffer16BitAccess,
+ storagePushConstant16,
+ storageInputOutput16 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default;
#else
- bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
- ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) &&
- ( storagePushConstant16 == rhs.storagePushConstant16 ) &&
- ( storageInputOutput16 == rhs.storageInputOutput16 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const &
- physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice16BitStorageFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice16BitStorageFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storagePushConstant16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageInputOutput16 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevice4444FormatsFeaturesEXT
{
using NativeType = VkPhysicalDevice4444FormatsFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>( this );
}
- operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) &&
- ( formatA4B4G4R4 == rhs.formatA4B4G4R4 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevice4444FormatsFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const &
- physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice4444FormatsFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice4444FormatsFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevice8BitStorageFeatures
{
using NativeType = VkPhysicalDevice8BitStorageFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>( this );
}
- operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevice8BitStorageFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default;
#else
bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) &&
- ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) &&
- ( storagePushConstant8 == rhs.storagePushConstant8 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const &
- physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice8BitStorageFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice8BitStorageFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storagePushConstant8 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceASTCDecodeFeaturesEXT
{
using NativeType = VkPhysicalDeviceASTCDecodeFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, decodeModeSharedExponent );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceASTCDecodeFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const &
- physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceASTCDecodeFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceASTCDecodeFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceAccelerationStructureFeaturesKHR
{
using NativeType = VkPhysicalDeviceAccelerationStructureFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ accelerationStructure,
+ accelerationStructureCaptureReplay,
+ accelerationStructureIndirectBuild,
+ accelerationStructureHostCommands,
+ descriptorBindingAccelerationStructureUpdateAfterBind );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( accelerationStructure == rhs.accelerationStructure ) &&
- ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) &&
- ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) &&
- ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) &&
- ( descriptorBindingAccelerationStructureUpdateAfterBind ==
- rhs.descriptorBindingAccelerationStructureUpdateAfterBind );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceAccelerationStructureFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const &
- physicalDeviceAccelerationStructureFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructureFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceAccelerationStructurePropertiesKHR
{
using NativeType = VkPhysicalDeviceAccelerationStructurePropertiesKHR;
return *this;
}
- operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>( this );
}
- operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ maxGeometryCount,
+ maxInstanceCount,
+ maxPrimitiveCount,
+ maxPerStageDescriptorAccelerationStructures,
+ maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
+ maxDescriptorSetAccelerationStructures,
+ maxDescriptorSetUpdateAfterBindAccelerationStructures,
+ minAccelerationStructureScratchOffsetAlignment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) &&
- ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxPrimitiveCount == rhs.maxPrimitiveCount ) &&
- ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) &&
- ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures ==
- rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) &&
- ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) &&
- ( maxDescriptorSetUpdateAfterBindAccelerationStructures ==
- rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) &&
- ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceAccelerationStructurePropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const &
- physicalDeviceAccelerationStructurePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructurePropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t,
- seed,
- physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t,
- seed,
- physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
{
using NativeType = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, advancedBlendCoherentOperations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const &
- physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
{
using NativeType = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ advancedBlendMaxColorAttachments,
+ advancedBlendIndependentBlend,
+ advancedBlendNonPremultipliedSrcColor,
+ advancedBlendNonPremultipliedDstColor,
+ advancedBlendCorrelatedOverlap,
+ advancedBlendAllOperations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) &&
- ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) &&
- ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) &&
- ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) &&
- ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) &&
- ( advancedBlendAllOperations == rhs.advancedBlendAllOperations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const &
- physicalDeviceBlendOperationAdvancedPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceBorderColorSwizzleFeaturesEXT
{
using NativeType = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) &&
- ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const &
- physicalDeviceBorderColorSwizzleFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceBufferDeviceAddressFeatures
{
using NativeType = VkPhysicalDeviceBufferDeviceAddressFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>( this );
}
- operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
- ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
- ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const &
- physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
{
using NativeType = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
- ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
- ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const &
- physicalDeviceBufferDeviceAddressFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCoherentMemoryFeaturesAMD
{
using NativeType = VkPhysicalDeviceCoherentMemoryFeaturesAMD;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>( this );
}
- operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceCoherentMemory );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default;
#else
bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCoherentMemoryFeaturesAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const &
- physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoherentMemoryFeaturesAMD.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceColorWriteEnableFeaturesEXT
{
using NativeType = VkPhysicalDeviceColorWriteEnableFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, colorWriteEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceColorWriteEnableFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const &
- physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceColorWriteEnableFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
{
using NativeType = VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>( this );
}
- operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) &&
- ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const &
- physicalDeviceComputeShaderDerivativesFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceConditionalRenderingFeaturesEXT
{
using NativeType = VkPhysicalDeviceConditionalRenderingFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) &&
- ( inheritedConditionalRendering == rhs.inheritedConditionalRendering );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceConditionalRenderingFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const &
- physicalDeviceConditionalRenderingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConditionalRenderingFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceConservativeRasterizationPropertiesEXT
{
using NativeType = VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ float const &,
+ float const &,
+ float const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ primitiveOverestimationSize,
+ maxExtraPrimitiveOverestimationSize,
+ extraPrimitiveOverestimationSizeGranularity,
+ primitiveUnderestimation,
+ conservativePointAndLineRasterization,
+ degenerateTrianglesRasterized,
+ degenerateLinesRasterized,
+ fullyCoveredFragmentShaderInputVariable,
+ conservativeRasterizationPostDepthCoverage );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) &&
- ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) &&
- ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) &&
- ( primitiveUnderestimation == rhs.primitiveUnderestimation ) &&
- ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) &&
- ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) &&
- ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) &&
- ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) &&
- ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
- physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize );
- VULKAN_HPP_HASH_COMBINE(
- float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize );
- VULKAN_HPP_HASH_COMBINE(
- float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCooperativeMatrixFeaturesNV
{
using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>( this );
}
- operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) &&
- ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCooperativeMatrixFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const &
- physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCooperativeMatrixPropertiesNV
{
using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesNV;
return *this;
}
- operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>( this );
}
- operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ShaderStageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, cooperativeMatrixSupportedStages );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCooperativeMatrixPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const &
- physicalDeviceCooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags,
- seed,
- physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCornerSampledImageFeaturesNV
{
using NativeType = VkPhysicalDeviceCornerSampledImageFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>( this );
}
- operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, cornerSampledImage );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCornerSampledImageFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const &
- physicalDeviceCornerSampledImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCornerSampledImageFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCornerSampledImageFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCoverageReductionModeFeaturesNV
{
using NativeType = VkPhysicalDeviceCoverageReductionModeFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>( this );
}
- operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, coverageReductionMode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCoverageReductionModeFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const &
- physicalDeviceCoverageReductionModeFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoverageReductionModeFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCustomBorderColorFeaturesEXT
{
using NativeType = VkPhysicalDeviceCustomBorderColorFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) &&
- ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCustomBorderColorFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const &
- physicalDeviceCustomBorderColorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceCustomBorderColorPropertiesEXT
{
using NativeType = VkPhysicalDeviceCustomBorderColorPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxCustomBorderColorSamplers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceCustomBorderColorPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const &
- physicalDeviceCustomBorderColorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
{
using NativeType = VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>( this );
}
- operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, dedicatedAllocationImageAliasing );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
- physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDepthClipControlFeaturesEXT
{
using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, depthClipControl );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDepthClipControlFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const &
- physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipControlFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipControlFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDepthClipEnableFeaturesEXT
{
using NativeType = VkPhysicalDeviceDepthClipEnableFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, depthClipEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDepthClipEnableFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const &
- physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipEnableFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDepthStencilResolveProperties
{
using NativeType = VkPhysicalDeviceDepthStencilResolveProperties;
return *this;
}
- operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties *>( this );
}
- operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ supportedDepthResolveModes,
+ supportedStencilResolveModes,
+ independentResolveNone,
+ independentResolve );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) &&
- ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) &&
- ( independentResolveNone == rhs.independentResolveNone ) &&
- ( independentResolve == rhs.independentResolve );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const &
- physicalDeviceDepthStencilResolveProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthStencilResolveProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthStencilResolveProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags,
- seed,
- physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags,
- seed,
- physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolve );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDescriptorIndexingFeatures
{
using NativeType = VkPhysicalDeviceDescriptorIndexingFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>( this );
}
- operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ shaderInputAttachmentArrayDynamicIndexing,
+ shaderUniformTexelBufferArrayDynamicIndexing,
+ shaderStorageTexelBufferArrayDynamicIndexing,
+ shaderUniformBufferArrayNonUniformIndexing,
+ shaderSampledImageArrayNonUniformIndexing,
+ shaderStorageBufferArrayNonUniformIndexing,
+ shaderStorageImageArrayNonUniformIndexing,
+ shaderInputAttachmentArrayNonUniformIndexing,
+ shaderUniformTexelBufferArrayNonUniformIndexing,
+ shaderStorageTexelBufferArrayNonUniformIndexing,
+ descriptorBindingUniformBufferUpdateAfterBind,
+ descriptorBindingSampledImageUpdateAfterBind,
+ descriptorBindingStorageImageUpdateAfterBind,
+ descriptorBindingStorageBufferUpdateAfterBind,
+ descriptorBindingUniformTexelBufferUpdateAfterBind,
+ descriptorBindingStorageTexelBufferUpdateAfterBind,
+ descriptorBindingUpdateUnusedWhilePending,
+ descriptorBindingPartiallyBound,
+ descriptorBindingVariableDescriptorCount,
+ runtimeDescriptorArray );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const &
- physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDescriptorIndexingProperties
{
using NativeType = VkPhysicalDeviceDescriptorIndexingProperties;
return *this;
}
- operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties *>( this );
}
- operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ maxUpdateAfterBindDescriptorsInAllPools,
+ shaderUniformBufferArrayNonUniformIndexingNative,
+ shaderSampledImageArrayNonUniformIndexingNative,
+ shaderStorageBufferArrayNonUniformIndexingNative,
+ shaderStorageImageArrayNonUniformIndexingNative,
+ shaderInputAttachmentArrayNonUniformIndexingNative,
+ robustBufferAccessUpdateAfterBind,
+ quadDivergentImplicitLod,
+ maxPerStageDescriptorUpdateAfterBindSamplers,
+ maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ maxPerStageDescriptorUpdateAfterBindSampledImages,
+ maxPerStageDescriptorUpdateAfterBindStorageImages,
+ maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ maxPerStageUpdateAfterBindResources,
+ maxDescriptorSetUpdateAfterBindSamplers,
+ maxDescriptorSetUpdateAfterBindUniformBuffers,
+ maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ maxDescriptorSetUpdateAfterBindStorageBuffers,
+ maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ maxDescriptorSetUpdateAfterBindSampledImages,
+ maxDescriptorSetUpdateAfterBindStorageImages,
+ maxDescriptorSetUpdateAfterBindInputAttachments );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const &
- physicalDeviceDescriptorIndexingProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
{
using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>( this );
}
- operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceGeneratedCommands );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( deviceGeneratedCommands == rhs.deviceGeneratedCommands );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &
- physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
{
using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
return *this;
}
- operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>( this );
}
- operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ maxGraphicsShaderGroupCount,
+ maxIndirectSequenceCount,
+ maxIndirectCommandsTokenCount,
+ maxIndirectCommandsStreamCount,
+ maxIndirectCommandsTokenOffset,
+ maxIndirectCommandsStreamStride,
+ minSequencesCountBufferOffsetAlignment,
+ minSequencesIndexBufferOffsetAlignment,
+ minIndirectCommandsBufferOffsetAlignment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &
- physicalDeviceDeviceGeneratedCommandsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDeviceMemoryReportFeaturesEXT
{
using NativeType = VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceMemoryReport );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const &
- physicalDeviceDeviceMemoryReportFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDiagnosticsConfigFeaturesNV
{
using NativeType = VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>( this );
}
- operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, diagnosticsConfig );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const &
- physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDiscardRectanglePropertiesEXT
{
using NativeType = VkPhysicalDeviceDiscardRectanglePropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>( this );
}
- operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxDiscardRectangles );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDiscardRectanglePropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const &
- physicalDeviceDiscardRectanglePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiscardRectanglePropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDriverProperties
{
using NativeType = VkPhysicalDeviceDriverProperties;
return *this;
}
- operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDriverProperties *>( this );
}
- operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDriverProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DriverId const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ConformanceVersion const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) &&
- ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) &&
- ( conformanceVersion == rhs.conformanceVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDriverProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDriverProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceDriverProperties.driverID );
- for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverName[i] );
- }
- for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverInfo[i] );
- }
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceDriverProperties.conformanceVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDrmPropertiesEXT
{
using NativeType = VkPhysicalDeviceDrmPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ int64_t const &,
+ int64_t const &,
+ int64_t const &,
+ int64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) &&
- ( hasRender == rhs.hasRender ) && ( primaryMajor == rhs.primaryMajor ) &&
- ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) &&
- ( renderMinor == rhs.renderMinor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDrmPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDrmPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDrmPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasPrimary );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasRender );
- VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMajor );
- VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMinor );
- VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMajor );
- VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMinor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceDynamicRenderingFeaturesKHR
{
using NativeType = VkPhysicalDeviceDynamicRenderingFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceDynamicRenderingFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDynamicRenderingFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceDynamicRenderingFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceDynamicRenderingFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, dynamicRendering );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDynamicRenderingFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceDynamicRenderingFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR const &
- physicalDeviceDynamicRenderingFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDynamicRenderingFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDynamicRenderingFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDynamicRenderingFeaturesKHR.dynamicRendering );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExclusiveScissorFeaturesNV
{
using NativeType = VkPhysicalDeviceExclusiveScissorFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>( this );
}
- operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, exclusiveScissor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceExclusiveScissorFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const &
- physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExclusiveScissorFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExclusiveScissorFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExtendedDynamicState2FeaturesEXT
{
using NativeType = VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
}
- operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( extendedDynamicState2 == rhs.extendedDynamicState2 ) &&
- ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) &&
- ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const &
- physicalDeviceExtendedDynamicState2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExtendedDynamicStateFeaturesEXT
{
using NativeType = VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, extendedDynamicState );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const &
- physicalDeviceExtendedDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExternalBufferInfo
{
using NativeType = VkPhysicalDeviceExternalBufferInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( this );
}
- operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::BufferCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::BufferUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, usage, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default;
#else
bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalBufferInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalBufferInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, physicalDeviceExternalBufferInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, physicalDeviceExternalBufferInfo.usage );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalBufferInfo.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExternalFenceInfo
{
using NativeType = VkPhysicalDeviceExternalFenceInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( this );
}
- operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default;
#else
bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalFenceInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalFenceInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, physicalDeviceExternalFenceInfo.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExternalImageFormatInfo
{
using NativeType = VkPhysicalDeviceExternalImageFormatInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>( this );
}
- operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default;
#else
bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const &
- physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalImageFormatInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalImageFormatInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalImageFormatInfo.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExternalMemoryHostPropertiesEXT
{
using NativeType = VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, minImportedHostPointerAlignment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const &
- physicalDeviceExternalMemoryHostPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
- seed,
- physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExternalMemoryRDMAFeaturesNV
{
using NativeType = VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>( this );
}
- operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, externalMemoryRDMA );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const &
- physicalDeviceExternalMemoryRDMAFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceExternalSemaphoreInfo
{
using NativeType = VkPhysicalDeviceExternalSemaphoreInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( this );
}
- operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default;
#else
bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const &
- physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalSemaphoreInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalSemaphoreInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, physicalDeviceExternalSemaphoreInfo.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFeatures2
{
using NativeType = VkPhysicalDeviceFeatures2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFeatures2 *>( this );
}
- operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFeatures2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, features );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default;
#else
bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFeatures2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFeatures2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures, seed, physicalDeviceFeatures2.features );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFloatControlsProperties
{
using NativeType = VkPhysicalDeviceFloatControlsProperties;
return *this;
}
- operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties *>( this );
}
- operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFloatControlsProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+ VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ denormBehaviorIndependence,
+ roundingModeIndependence,
+ shaderSignedZeroInfNanPreserveFloat16,
+ shaderSignedZeroInfNanPreserveFloat32,
+ shaderSignedZeroInfNanPreserveFloat64,
+ shaderDenormPreserveFloat16,
+ shaderDenormPreserveFloat32,
+ shaderDenormPreserveFloat64,
+ shaderDenormFlushToZeroFloat16,
+ shaderDenormFlushToZeroFloat32,
+ shaderDenormFlushToZeroFloat64,
+ shaderRoundingModeRTEFloat16,
+ shaderRoundingModeRTEFloat32,
+ shaderRoundingModeRTEFloat64,
+ shaderRoundingModeRTZFloat16,
+ shaderRoundingModeRTZFloat32,
+ shaderRoundingModeRTZFloat64 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const &
- physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFloatControlsProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFloatControlsProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
- seed,
- physicalDeviceFloatControlsProperties.denormBehaviorIndependence );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
- seed,
- physicalDeviceFloatControlsProperties.roundingModeIndependence );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentDensityMap2FeaturesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
}
- operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentDensityMapDeferred );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const &
- physicalDeviceFragmentDensityMap2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentDensityMap2PropertiesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
}
- operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ subsampledLoads,
+ subsampledCoarseReconstructionEarlyAccess,
+ maxSubsampledArrayLayers,
+ maxDescriptorSetSubsampledSamplers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) &&
- ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) &&
- ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) &&
- ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const &
- physicalDeviceFragmentDensityMap2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentDensityMapFeaturesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) &&
- ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) &&
- ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
+ struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
+ {
+ using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const &
- physicalDeviceFragmentDensityMapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages );
- return seed;
- }
-};
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+ StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+ VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {} ) VULKAN_HPP_NOEXCEPT
+ : fragmentDensityMapOffset( fragmentDensityMapOffset_ )
+ {}
+
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+ PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+ VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+ *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs ) )
+ {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+ operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+ operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this =
+ *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+ setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
+ setFragmentDensityMapOffset( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ ) VULKAN_HPP_NOEXCEPT
+ {
+ fragmentDensityMapOffset = fragmentDensityMapOffset_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ explicit operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
+ }
+
+ explicit operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
+ }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentDensityMapOffset );
+ }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default;
+#else
+ bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() == rhs.reflect();
+ }
+
+ bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() != rhs.reflect();
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset = {};
+ };
+ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
+ sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
+ "struct and wrapper have different size!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
+ "struct wrapper is not a standard layout!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
+ "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
+ {
+ using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+ };
+
+ struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
+ {
+ using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+ StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+ VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {} ) VULKAN_HPP_NOEXCEPT
+ : fragmentDensityOffsetGranularity( fragmentDensityOffsetGranularity_ )
+ {}
+
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+ PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+ VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+ *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs ) )
+ {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &
+ operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &
+ operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this =
+ *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs );
+ return *this;
+ }
+
+ explicit operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
+ }
+
+ explicit operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
+ }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentDensityOffsetGranularity );
+ }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default;
+#else
+ bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() == rhs.reflect();
+ }
+
+ bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() != rhs.reflect();
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity = {};
+ };
+ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
+ sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
+ "struct and wrapper have different size!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
+ "struct wrapper is not a standard layout!" );
+ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
+ "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
+ {
+ using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+ };
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentDensityMapPropertiesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) &&
- ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) &&
- ( fragmentDensityInvocations == rhs.fragmentDensityInvocations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const &
- physicalDeviceFragmentDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
{
using NativeType = VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>( this );
}
- operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentShaderBarycentric );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const &
- physicalDeviceFragmentShaderBarycentricFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.fragmentShaderBarycentric );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
{
using NativeType = VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) &&
- ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) &&
- ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const &
- physicalDeviceFragmentShaderInterlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
{
using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>( this );
}
- operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) &&
- ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) &&
- ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &
- physicalDeviceFragmentShadingRateEnumsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
{
using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>( this );
}
- operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &
- physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits,
- seed,
- physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShadingRateFeaturesKHR
{
using NativeType = VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) &&
- ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) &&
- ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const &
- physicalDeviceFragmentShadingRateFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShadingRateKHR
{
using NativeType = VkPhysicalDeviceFragmentShadingRateKHR;
return *this;
}
- operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateKHR *>( this );
}
- operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, sampleCounts, fragmentSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) &&
- ( fragmentSize == rhs.fragmentSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShadingRateKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const &
- physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceFragmentShadingRateKHR.sampleCounts );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRateKHR.fragmentSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceFragmentShadingRatePropertiesKHR
{
using NativeType = VkPhysicalDeviceFragmentShadingRatePropertiesKHR;
return *this;
}
- operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>( this );
}
- operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ minFragmentShadingRateAttachmentTexelSize,
+ maxFragmentShadingRateAttachmentTexelSize,
+ maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
+ primitiveFragmentShadingRateWithMultipleViewports,
+ layeredShadingRateAttachments,
+ fragmentShadingRateNonTrivialCombinerOps,
+ maxFragmentSize,
+ maxFragmentSizeAspectRatio,
+ maxFragmentShadingRateCoverageSamples,
+ maxFragmentShadingRateRasterizationSamples,
+ fragmentShadingRateWithShaderDepthStencilWrites,
+ fragmentShadingRateWithSampleMask,
+ fragmentShadingRateWithShaderSampleMask,
+ fragmentShadingRateWithConservativeRasterization,
+ fragmentShadingRateWithFragmentShaderInterlock,
+ fragmentShadingRateWithCustomSampleLocations,
+ fragmentShadingRateStrictMultiplyCombiner );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) &&
- ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) &&
- ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio ==
- rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) &&
- ( primitiveFragmentShadingRateWithMultipleViewports ==
- rhs.primitiveFragmentShadingRateWithMultipleViewports ) &&
- ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) &&
- ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) &&
- ( maxFragmentSize == rhs.maxFragmentSize ) &&
- ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) &&
- ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) &&
- ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) &&
- ( fragmentShadingRateWithShaderDepthStencilWrites ==
- rhs.fragmentShadingRateWithShaderDepthStencilWrites ) &&
- ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) &&
- ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) &&
- ( fragmentShadingRateWithConservativeRasterization ==
- rhs.fragmentShadingRateWithConservativeRasterization ) &&
- ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) &&
- ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) &&
- ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const &
- physicalDeviceFragmentShadingRatePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT
{
using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, globalPriorityQuery );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT const &
- physicalDeviceGlobalPriorityQueryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.globalPriorityQuery );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceGroupProperties
{
using NativeType = VkPhysicalDeviceGroupProperties;
return *this;
}
- operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceGroupProperties *>( this );
}
- operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceGroupProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<
+ VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::PhysicalDevice, VK_MAX_DEVICE_GROUP_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
- ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGroupProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGroupProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceGroupProperties.physicalDeviceCount );
- for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PhysicalDevice, seed, physicalDeviceGroupProperties.physicalDevices[i] );
- }
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGroupProperties.subsetAllocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceHostQueryResetFeatures
{
using NativeType = VkPhysicalDeviceHostQueryResetFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>( this );
}
- operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, hostQueryReset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const &
- physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceHostQueryResetFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceHostQueryResetFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceHostQueryResetFeatures.hostQueryReset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceIDProperties
{
using NativeType = VkPhysicalDeviceIDProperties;
return *this;
}
- operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceIDProperties *>( this );
}
- operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceIDProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceIDProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) &&
- ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) &&
- ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIDProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIDProperties.pNext );
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceUUID[i] );
- }
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.driverUUID[i] );
- }
- for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceLUID[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceIDProperties.deviceNodeMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIDProperties.deviceLUIDValid );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceImageDrmFormatModifierInfoEXT
{
using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>( this );
}
- operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::SharingMode const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
- ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
- ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const &
- physicalDeviceImageDrmFormatModifierInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SharingMode, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceImageFormatInfo2
{
using NativeType = VkPhysicalDeviceImageFormatInfo2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( this );
}
- operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::ImageType const &,
+ VULKAN_HPP_NAMESPACE::ImageTiling const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::ImageCreateFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, format, type, tiling, usage, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default;
#else
bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) &&
- ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageFormatInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageFormatInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceImageFormatInfo2.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceImageFormatInfo2.type );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceImageFormatInfo2.tiling );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceImageFormatInfo2.usage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, physicalDeviceImageFormatInfo2.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceImageRobustnessFeaturesEXT
{
using NativeType = VkPhysicalDeviceImageRobustnessFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, robustImageAccess );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceImageRobustnessFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT const &
- physicalDeviceImageRobustnessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageRobustnessFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageRobustnessFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageRobustnessFeaturesEXT.robustImageAccess );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceImageViewImageFormatInfoEXT
{
using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>( this );
}
- operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageViewType const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageViewType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceImageViewImageFormatInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const &
- physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewImageFormatInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewImageFormatInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageViewType, seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceImageViewMinLodFeaturesEXT
{
using NativeType = VkPhysicalDeviceImageViewMinLodFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, minLod );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceImageViewMinLodFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const &
- physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewMinLodFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceImagelessFramebufferFeatures
{
using NativeType = VkPhysicalDeviceImagelessFramebufferFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>( this );
}
- operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imagelessFramebuffer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const &
- physicalDeviceImagelessFramebufferFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImagelessFramebufferFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImagelessFramebufferFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceIndexTypeUint8FeaturesEXT
{
using NativeType = VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
}
- operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, indexTypeUint8 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const &
- physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceInheritedViewportScissorFeaturesNV
{
using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>( this );
}
- operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, inheritedViewportScissor2D );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const &
- physicalDeviceInheritedViewportScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceInlineUniformBlockFeaturesEXT
{
using NativeType = VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) &&
- ( descriptorBindingInlineUniformBlockUpdateAfterBind ==
- rhs.descriptorBindingInlineUniformBlockUpdateAfterBind );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT const &
- physicalDeviceInlineUniformBlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInlineUniformBlockFeaturesEXT.inlineUniformBlock );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceInlineUniformBlockFeaturesEXT.descriptorBindingInlineUniformBlockUpdateAfterBind );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceInlineUniformBlockPropertiesEXT
{
using NativeType = VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ maxInlineUniformBlockSize,
+ maxPerStageDescriptorInlineUniformBlocks,
+ maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+ maxDescriptorSetInlineUniformBlocks,
+ maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) &&
- ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) &&
- ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ==
- rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) &&
- ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) &&
- ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks ==
- rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT const &
- physicalDeviceInlineUniformBlockPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxInlineUniformBlockSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorInlineUniformBlocks );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t,
- seed,
- physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetInlineUniformBlocks );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t,
- seed,
- physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceInvocationMaskFeaturesHUAWEI
{
using NativeType = VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>( this );
}
- operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, invocationMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default;
#else
bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const &
- physicalDeviceInvocationMaskFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceLimits
{
using NativeType = VkPhysicalDeviceLimits;
return *this;
}
- operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceLimits *>( this );
}
- operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceLimits *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ float const &,
+ float const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 2> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+ uint32_t const &,
+ size_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ int32_t const &,
+ uint32_t const &,
+ int32_t const &,
+ uint32_t const &,
+ float const &,
+ float const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ float const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+ float const &,
+ float const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( maxImageDimension1D,
+ maxImageDimension2D,
+ maxImageDimension3D,
+ maxImageDimensionCube,
+ maxImageArrayLayers,
+ maxTexelBufferElements,
+ maxUniformBufferRange,
+ maxStorageBufferRange,
+ maxPushConstantsSize,
+ maxMemoryAllocationCount,
+ maxSamplerAllocationCount,
+ bufferImageGranularity,
+ sparseAddressSpaceSize,
+ maxBoundDescriptorSets,
+ maxPerStageDescriptorSamplers,
+ maxPerStageDescriptorUniformBuffers,
+ maxPerStageDescriptorStorageBuffers,
+ maxPerStageDescriptorSampledImages,
+ maxPerStageDescriptorStorageImages,
+ maxPerStageDescriptorInputAttachments,
+ maxPerStageResources,
+ maxDescriptorSetSamplers,
+ maxDescriptorSetUniformBuffers,
+ maxDescriptorSetUniformBuffersDynamic,
+ maxDescriptorSetStorageBuffers,
+ maxDescriptorSetStorageBuffersDynamic,
+ maxDescriptorSetSampledImages,
+ maxDescriptorSetStorageImages,
+ maxDescriptorSetInputAttachments,
+ maxVertexInputAttributes,
+ maxVertexInputBindings,
+ maxVertexInputAttributeOffset,
+ maxVertexInputBindingStride,
+ maxVertexOutputComponents,
+ maxTessellationGenerationLevel,
+ maxTessellationPatchSize,
+ maxTessellationControlPerVertexInputComponents,
+ maxTessellationControlPerVertexOutputComponents,
+ maxTessellationControlPerPatchOutputComponents,
+ maxTessellationControlTotalOutputComponents,
+ maxTessellationEvaluationInputComponents,
+ maxTessellationEvaluationOutputComponents,
+ maxGeometryShaderInvocations,
+ maxGeometryInputComponents,
+ maxGeometryOutputComponents,
+ maxGeometryOutputVertices,
+ maxGeometryTotalOutputComponents,
+ maxFragmentInputComponents,
+ maxFragmentOutputAttachments,
+ maxFragmentDualSrcAttachments,
+ maxFragmentCombinedOutputResources,
+ maxComputeSharedMemorySize,
+ maxComputeWorkGroupCount,
+ maxComputeWorkGroupInvocations,
+ maxComputeWorkGroupSize,
+ subPixelPrecisionBits,
+ subTexelPrecisionBits,
+ mipmapPrecisionBits,
+ maxDrawIndexedIndexValue,
+ maxDrawIndirectCount,
+ maxSamplerLodBias,
+ maxSamplerAnisotropy,
+ maxViewports,
+ maxViewportDimensions,
+ viewportBoundsRange,
+ viewportSubPixelBits,
+ minMemoryMapAlignment,
+ minTexelBufferOffsetAlignment,
+ minUniformBufferOffsetAlignment,
+ minStorageBufferOffsetAlignment,
+ minTexelOffset,
+ maxTexelOffset,
+ minTexelGatherOffset,
+ maxTexelGatherOffset,
+ minInterpolationOffset,
+ maxInterpolationOffset,
+ subPixelInterpolationOffsetBits,
+ maxFramebufferWidth,
+ maxFramebufferHeight,
+ maxFramebufferLayers,
+ framebufferColorSampleCounts,
+ framebufferDepthSampleCounts,
+ framebufferStencilSampleCounts,
+ framebufferNoAttachmentsSampleCounts,
+ maxColorAttachments,
+ sampledImageColorSampleCounts,
+ sampledImageIntegerSampleCounts,
+ sampledImageDepthSampleCounts,
+ sampledImageStencilSampleCounts,
+ storageImageSampleCounts,
+ maxSampleMaskWords,
+ timestampComputeAndGraphics,
+ timestampPeriod,
+ maxClipDistances,
+ maxCullDistances,
+ maxCombinedClipAndCullDistances,
+ discreteQueuePriorities,
+ pointSizeRange,
+ lineWidthRange,
+ pointSizeGranularity,
+ lineWidthGranularity,
+ strictLines,
+ standardSampleLocations,
+ optimalBufferCopyOffsetAlignment,
+ optimalBufferCopyRowPitchAlignment,
+ nonCoherentAtomSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceLimits const & ) const = default;
#else
bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) &&
- ( maxImageDimension3D == rhs.maxImageDimension3D ) &&
- ( maxImageDimensionCube == rhs.maxImageDimensionCube ) &&
- ( maxImageArrayLayers == rhs.maxImageArrayLayers ) &&
- ( maxTexelBufferElements == rhs.maxTexelBufferElements ) &&
- ( maxUniformBufferRange == rhs.maxUniformBufferRange ) &&
- ( maxStorageBufferRange == rhs.maxStorageBufferRange ) &&
- ( maxPushConstantsSize == rhs.maxPushConstantsSize ) &&
- ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) &&
- ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) &&
- ( bufferImageGranularity == rhs.bufferImageGranularity ) &&
- ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) &&
- ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) &&
- ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) &&
- ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) &&
- ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) &&
- ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) &&
- ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) &&
- ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) &&
- ( maxPerStageResources == rhs.maxPerStageResources ) &&
- ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) &&
- ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) &&
- ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) &&
- ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) &&
- ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) &&
- ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) &&
- ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) &&
- ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) &&
- ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) &&
- ( maxVertexInputBindings == rhs.maxVertexInputBindings ) &&
- ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) &&
- ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) &&
- ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) &&
- ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) &&
- ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) &&
- ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) &&
- ( maxTessellationControlPerVertexOutputComponents ==
- rhs.maxTessellationControlPerVertexOutputComponents ) &&
- ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) &&
- ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) &&
- ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) &&
- ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) &&
- ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) &&
- ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) &&
- ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) &&
- ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) &&
- ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) &&
- ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) &&
- ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) &&
- ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) &&
- ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) &&
- ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) &&
- ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) &&
- ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) &&
- ( maxComputeWorkGroupSize == rhs.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 == rhs.maxViewportDimensions ) &&
- ( viewportBoundsRange == rhs.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 == rhs.pointSizeRange ) &&
- ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) &&
- ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) &&
- ( standardSampleLocations == rhs.standardSampleLocations ) &&
- ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) &&
- ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) &&
- ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>::value,
"PhysicalDeviceLimits is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension1D );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension2D );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension3D );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimensionCube );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageArrayLayers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelBufferElements );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxUniformBufferRange );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxStorageBufferRange );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPushConstantsSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxMemoryAllocationCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSamplerAllocationCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.bufferImageGranularity );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.sparseAddressSpaceSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxBoundDescriptorSets );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSamplers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageResources );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSamplers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSampledImages );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageImages );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetInputAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributes );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindings );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributeOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindingStride );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationGenerationLevel );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationPatchSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryShaderInvocations );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryInputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputVertices );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryTotalOutputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentInputComponents );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentOutputAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentDualSrcAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentCombinedOutputResources );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeSharedMemorySize );
- for ( size_t i = 0; i < 3; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupInvocations );
- for ( size_t i = 0; i < 3; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelPrecisionBits );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subTexelPrecisionBits );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.mipmapPrecisionBits );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndexedIndexValue );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndirectCount );
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerLodBias );
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerAnisotropy );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewports );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewportDimensions[i] );
- }
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.viewportBoundsRange[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.viewportSubPixelBits );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, physicalDeviceLimits.minMemoryMapAlignment );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minTexelBufferOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minUniformBufferOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minStorageBufferOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelOffset );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelGatherOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelGatherOffset );
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.minInterpolationOffset );
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxInterpolationOffset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelInterpolationOffsetBits );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferWidth );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferHeight );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferLayers );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferColorSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferDepthSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferStencilSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxColorAttachments );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageColorSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageIntegerSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageDepthSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageStencilSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.storageImageSampleCounts );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSampleMaskWords );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.timestampComputeAndGraphics );
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.timestampPeriod );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxClipDistances );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCullDistances );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCombinedClipAndCullDistances );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.discreteQueuePriorities );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeRange[i] );
- }
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthRange[i] );
- }
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeGranularity );
- VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthGranularity );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.strictLines );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.standardSampleLocations );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.nonCoherentAtomSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceLineRasterizationFeaturesEXT
{
using NativeType = VkPhysicalDeviceLineRasterizationFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ rectangularLines,
+ bresenhamLines,
+ smoothLines,
+ stippledRectangularLines,
+ stippledBresenhamLines,
+ stippledSmoothLines );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) &&
- ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) &&
- ( stippledRectangularLines == rhs.stippledRectangularLines ) &&
- ( stippledBresenhamLines == rhs.stippledBresenhamLines ) &&
- ( stippledSmoothLines == rhs.stippledSmoothLines );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceLineRasterizationFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const &
- physicalDeviceLineRasterizationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceLineRasterizationPropertiesEXT
{
using NativeType = VkPhysicalDeviceLineRasterizationPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, lineSubPixelPrecisionBits );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceLineRasterizationPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
+ struct PhysicalDeviceLinearColorAttachmentFeaturesNV
+ {
+ using NativeType = VkPhysicalDeviceLinearColorAttachmentFeaturesNV;
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const &
- physicalDeviceLineRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
- return seed;
- }
-};
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+ StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV(
+ VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment_ = {} ) VULKAN_HPP_NOEXCEPT
+ : linearColorAttachment( linearColorAttachment_ )
+ {}
+
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV(
+ PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceLinearColorAttachmentFeaturesNV( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs )
+ VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceLinearColorAttachmentFeaturesNV(
+ *reinterpret_cast<PhysicalDeviceLinearColorAttachmentFeaturesNV const *>( &rhs ) )
+ {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceLinearColorAttachmentFeaturesNV &
+ operator=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceLinearColorAttachmentFeaturesNV &
+ operator=( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV &
+ setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV &
+ setLinearColorAttachment( VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment_ ) VULKAN_HPP_NOEXCEPT
+ {
+ linearColorAttachment = linearColorAttachment_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ explicit operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>( this );
+ }
+
+ explicit operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>( this );
+ }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, linearColorAttachment );
+ }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default;
+#else
+ bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() == rhs.reflect();
+ }
+
+ bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() != rhs.reflect();
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment = {};
+ };
+ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) ==
+ sizeof( VkPhysicalDeviceLinearColorAttachmentFeaturesNV ),
+ "struct and wrapper have different size!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>::value,
+ "struct wrapper is not a standard layout!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>::value,
+ "PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" );
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV>
+ {
+ using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV;
+ };
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMaintenance3Properties
{
using NativeType = VkPhysicalDeviceMaintenance3Properties;
return *this;
}
- operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>( this );
}
- operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default;
#else
bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) &&
- ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const &
- physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance3Properties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance3Properties.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMaintenance4FeaturesKHR
{
using NativeType = VkPhysicalDeviceMaintenance4FeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceMaintenance4FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMaintenance4FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR *>( this );
}
- operator VkPhysicalDeviceMaintenance4FeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMaintenance4FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maintenance4 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMaintenance4FeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMaintenance4FeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR const &
- physicalDeviceMaintenance4FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4FeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4FeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMaintenance4FeaturesKHR.maintenance4 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMaintenance4PropertiesKHR
{
using NativeType = VkPhysicalDeviceMaintenance4PropertiesKHR;
return *this;
}
- operator VkPhysicalDeviceMaintenance4PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMaintenance4PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR *>( this );
}
- operator VkPhysicalDeviceMaintenance4PropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMaintenance4PropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxBufferSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMaintenance4PropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMaintenance4PropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR const &
- physicalDeviceMaintenance4PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4PropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4PropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance4PropertiesKHR.maxBufferSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMemoryBudgetPropertiesEXT
{
using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, heapBudget, heapUsage );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) &&
- ( heapUsage == rhs.heapUsage );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMemoryBudgetPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const &
- physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryBudgetPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext );
- for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
- {
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] );
- }
- for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
- {
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMemoryPriorityFeaturesEXT
{
using NativeType = VkPhysicalDeviceMemoryPriorityFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryPriority );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMemoryPriorityFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const &
- physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryPriorityFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMemoryProperties
{
using NativeType = VkPhysicalDeviceMemoryProperties;
return *this;
}
- operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties *>( this );
}
- operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryType, VK_MAX_MEMORY_TYPES> const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryHeap, VK_MAX_MEMORY_HEAPS> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) &&
- ( memoryHeapCount == rhs.memoryHeapCount ) && ( memoryHeaps == rhs.memoryHeaps );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>::value,
"PhysicalDeviceMemoryProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryTypeCount );
- for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryType, seed, physicalDeviceMemoryProperties.memoryTypes[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryHeapCount );
- for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeap, seed, physicalDeviceMemoryProperties.memoryHeaps[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMemoryProperties2
{
using NativeType = VkPhysicalDeviceMemoryProperties2;
return *this;
}
- operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2 *>( this );
}
- operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default;
#else
bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryProperties2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryProperties2.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties, seed, physicalDeviceMemoryProperties2.memoryProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMeshShaderFeaturesNV
{
using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>( this );
}
- operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, taskShader, meshShader );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) &&
- ( meshShader == rhs.meshShader );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMeshShaderFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const &
- physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.taskShader );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.meshShader );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMeshShaderPropertiesNV
{
using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV;
return *this;
}
- operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>( this );
}
- operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ maxDrawMeshTasksCount,
+ maxTaskWorkGroupInvocations,
+ maxTaskWorkGroupSize,
+ maxTaskTotalMemorySize,
+ maxTaskOutputCount,
+ maxMeshWorkGroupInvocations,
+ maxMeshWorkGroupSize,
+ maxMeshTotalMemorySize,
+ maxMeshOutputVertices,
+ maxMeshOutputPrimitives,
+ maxMeshMultiviewViewCount,
+ meshOutputPerVertexGranularity,
+ meshOutputPerPrimitiveGranularity );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) &&
- ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) &&
- ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) &&
- ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) &&
- ( maxTaskOutputCount == rhs.maxTaskOutputCount ) &&
- ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) &&
- ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) &&
- ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) &&
- ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) &&
- ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) &&
- ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) &&
- ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) &&
- ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMeshShaderPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const &
- physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations );
- for ( size_t i = 0; i < 3; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations );
- for ( size_t i = 0; i < 3; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMultiDrawFeaturesEXT
{
using NativeType = VkPhysicalDeviceMultiDrawFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, multiDraw );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMultiDrawFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const &
- physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMultiDrawPropertiesEXT
{
using NativeType = VkPhysicalDeviceMultiDrawPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxMultiDrawCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMultiDrawPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const &
- physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMultiviewFeatures
{
using NativeType = VkPhysicalDeviceMultiviewFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>( this );
}
- operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) &&
- ( multiviewGeometryShader == rhs.multiviewGeometryShader ) &&
- ( multiviewTessellationShader == rhs.multiviewTessellationShader );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiview );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
{
using NativeType = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
return *this;
}
- operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>( this );
}
- operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, perViewPositionAllComponents );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
- physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMultiviewProperties
{
using NativeType = VkPhysicalDeviceMultiviewProperties;
return *this;
}
- operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>( this );
}
- operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) &&
- ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const &
- physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
{
using NativeType = VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
}
- operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, mutableDescriptorType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default;
#else
bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &
- physicalDeviceMutableDescriptorTypeFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePCIBusInfoPropertiesEXT
{
using NativeType = VkPhysicalDevicePCIBusInfoPropertiesEXT;
return *this;
}
- operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>( this );
}
- operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) &&
- ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && ( pciFunction == rhs.pciFunction );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePCIBusInfoPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const &
- physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePCIBusInfoPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePCIBusInfoPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
{
using NativeType = VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>( this );
}
- operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pageableDeviceLocalMemory );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &
- physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePerformanceQueryFeaturesKHR
{
using NativeType = VkPhysicalDevicePerformanceQueryFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>( this );
}
- operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) &&
- ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePerformanceQueryFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const &
- physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePerformanceQueryPropertiesKHR
{
using NativeType = VkPhysicalDevicePerformanceQueryPropertiesKHR;
return *this;
}
- operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR *>( this );
}
- operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, allowCommandBufferQueryCopies );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePerformanceQueryPropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const &
- physicalDevicePerformanceQueryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT
{
using NativeType = VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>( this );
}
- operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pipelineCreationCacheControl );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT const &
- physicalDevicePipelineCreationCacheControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePipelineCreationCacheControlFeaturesEXT.pipelineCreationCacheControl );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
{
using NativeType = VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>( this );
}
- operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pipelineExecutableInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( pipelineExecutableInfo == rhs.pipelineExecutableInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
- physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePointClippingProperties
{
using NativeType = VkPhysicalDevicePointClippingProperties;
return *this;
}
- operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>( this );
}
- operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePointClippingProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PointClippingBehavior const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pointClippingBehavior );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default;
#else
bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const &
- physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePointClippingProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePointClippingProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDevicePointClippingProperties.pointClippingBehavior );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct PhysicalDevicePortabilitySubsetFeaturesKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>( this );
}
- operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ constantAlphaColorBlendFactors,
+ events,
+ imageViewFormatReinterpretation,
+ imageViewFormatSwizzle,
+ imageView2DOn3DImage,
+ multisampleArrayImage,
+ mutableComparisonSamplers,
+ pointPolygons,
+ samplerMipLodBias,
+ separateStencilMaskRef,
+ shaderSampleRateInterpolationFunctions,
+ tessellationIsolines,
+ tessellationPointMode,
+ triangleFans,
+ vertexAttributeAccessBeyondStride );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default;
# else
bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && ( events == rhs.events ) &&
- ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) &&
- ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) &&
- ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) &&
- ( multisampleArrayImage == rhs.multisampleArrayImage ) &&
- ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && ( pointPolygons == rhs.pointPolygons ) &&
- ( samplerMipLodBias == rhs.samplerMipLodBias ) &&
- ( separateStencilMaskRef == rhs.separateStencilMaskRef ) &&
- ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) &&
- ( tessellationIsolines == rhs.tessellationIsolines ) &&
- ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) &&
- ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = PhysicalDevicePortabilitySubsetFeaturesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const &
- physicalDevicePortabilitySubsetFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.events );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR *>( this );
}
- operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, minVertexInputBindingStrideAlignment );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default;
# else
bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = PhysicalDevicePortabilitySubsetPropertiesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const &
- physicalDevicePortabilitySubsetPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
struct PhysicalDevicePresentIdFeaturesKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>( this );
}
- operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, presentId );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePresentIdFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const &
- physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentIdFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentIdFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentIdFeaturesKHR.presentId );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePresentWaitFeaturesKHR
{
using NativeType = VkPhysicalDevicePresentWaitFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>( this );
}
- operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, presentWait );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePresentWaitFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const &
- physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentWaitFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentWaitFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentWaitFeaturesKHR.presentWait );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
{
using NativeType = VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>( this );
}
- operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) &&
- ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
- physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePrivateDataFeaturesEXT
{
using NativeType = VkPhysicalDevicePrivateDataFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT *>( this );
}
- operator VkPhysicalDevicePrivateDataFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePrivateDataFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, privateData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePrivateDataFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePrivateDataFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT const &
- physicalDevicePrivateDataFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrivateDataFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrivateDataFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePrivateDataFeaturesEXT.privateData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSparseProperties
{
using NativeType = VkPhysicalDeviceSparseProperties;
return *this;
}
- operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSparseProperties *>( this );
}
- operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSparseProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( residencyStandard2DBlockShape,
+ residencyStandard2DMultisampleBlockShape,
+ residencyStandard3DBlockShape,
+ residencyAlignedMipSize,
+ residencyNonResidentStrict );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) &&
- ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) &&
- ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) &&
- ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) &&
- ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>::value,
"PhysicalDeviceSparseProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceProperties
{
using NativeType = VkPhysicalDeviceProperties;
return *this;
}
- operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceProperties *>( this );
}
- operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceType const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &,
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( apiVersion,
+ driverVersion,
+ vendorID,
+ deviceID,
+ deviceType,
+ deviceName,
+ pipelineCacheUUID,
+ limits,
+ sparseProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) &&
- ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && ( deviceType == rhs.deviceType ) &&
- ( deviceName == rhs.deviceName ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) &&
- ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>::value,
"PhysicalDeviceProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.apiVersion );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.driverVersion );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.vendorID );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.deviceID );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceType, seed, physicalDeviceProperties.deviceType );
- for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceProperties.deviceName[i] );
- }
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceProperties.pipelineCacheUUID[i] );
- }
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits, seed, physicalDeviceProperties.limits );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties, seed, physicalDeviceProperties.sparseProperties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceProperties2
{
using NativeType = VkPhysicalDeviceProperties2;
return *this;
}
- operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceProperties2 *>( this );
}
- operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceProperties2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, properties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceProperties2 const & ) const = default;
#else
bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProperties2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProperties2.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties, seed, physicalDeviceProperties2.properties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceProtectedMemoryFeatures
{
using NativeType = VkPhysicalDeviceProtectedMemoryFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>( this );
}
- operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, protectedMemory );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceProtectedMemoryFeatures;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const &
- physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryFeatures.protectedMemory );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceProtectedMemoryProperties
{
using NativeType = VkPhysicalDeviceProtectedMemoryProperties;
return *this;
}
- operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>( this );
}
- operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, protectedNoFault );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceProtectedMemoryProperties;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const &
- physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryProperties.protectedNoFault );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceProvokingVertexFeaturesEXT
{
using NativeType = VkPhysicalDeviceProvokingVertexFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) &&
- ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceProvokingVertexFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const &
- physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceProvokingVertexPropertiesEXT
{
using NativeType = VkPhysicalDeviceProvokingVertexPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) &&
- ( transformFeedbackPreservesTriangleFanProvokingVertex ==
- rhs.transformFeedbackPreservesTriangleFanProvokingVertex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceProvokingVertexPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const &
- physicalDeviceProvokingVertexPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDevicePushDescriptorPropertiesKHR
{
using NativeType = VkPhysicalDevicePushDescriptorPropertiesKHR;
return *this;
}
- operator VkPhysicalDevicePushDescriptorPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePushDescriptorPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>( this );
}
- operator VkPhysicalDevicePushDescriptorPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDevicePushDescriptorPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxPushDescriptors );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDevicePushDescriptorPropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const &
- physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePushDescriptorPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePushDescriptorPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT
{
using NativeType = VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const &
- physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
{
using NativeType = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM *>( this );
}
- operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ rasterizationOrderColorAttachmentAccess,
+ rasterizationOrderDepthAttachmentAccess,
+ rasterizationOrderStencilAttachmentAccess );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & ) const = default;
#else
bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) &&
- ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) &&
- ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &
- physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderColorAttachmentAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderDepthAttachmentAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderStencilAttachmentAccess );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRayQueryFeaturesKHR
{
using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, rayQuery );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRayQueryFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const &
- physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayQueryFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayQueryFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayQueryFeaturesKHR.rayQuery );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRayTracingMotionBlurFeaturesNV
{
using NativeType = VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>( this );
}
- operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) &&
- ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const &
- physicalDeviceRayTracingMotionBlurFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRayTracingPipelineFeaturesKHR
{
using NativeType = VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ rayTracingPipeline,
+ rayTracingPipelineShaderGroupHandleCaptureReplay,
+ rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+ rayTracingPipelineTraceRaysIndirect,
+ rayTraversalPrimitiveCulling );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) &&
- ( rayTracingPipelineShaderGroupHandleCaptureReplay ==
- rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) &&
- ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed ==
- rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) &&
- ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) &&
- ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const &
- physicalDeviceRayTracingPipelineFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRayTracingPipelinePropertiesKHR
{
using NativeType = VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
return *this;
}
- operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>( this );
}
- operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ shaderGroupHandleSize,
+ maxRayRecursionDepth,
+ maxShaderGroupStride,
+ shaderGroupBaseAlignment,
+ shaderGroupHandleCaptureReplaySize,
+ maxRayDispatchInvocationCount,
+ shaderGroupHandleAlignment,
+ maxRayHitAttributeSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) &&
- ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) &&
- ( maxShaderGroupStride == rhs.maxShaderGroupStride ) &&
- ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) &&
- ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) &&
- ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) &&
- ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) &&
- ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const &
- physicalDeviceRayTracingPipelinePropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRayTracingPropertiesNV
{
using NativeType = VkPhysicalDeviceRayTracingPropertiesNV;
return *this;
}
- operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>( this );
}
- operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint64_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ shaderGroupHandleSize,
+ maxRecursionDepth,
+ maxShaderGroupStride,
+ shaderGroupBaseAlignment,
+ maxGeometryCount,
+ maxInstanceCount,
+ maxTriangleCount,
+ maxDescriptorSetAccelerationStructures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRayTracingPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const &
- physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
{
using NativeType = VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>( this );
}
- operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, representativeFragmentTest );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( representativeFragmentTest == rhs.representativeFragmentTest );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const &
- physicalDeviceRepresentativeFragmentTestFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRobustness2FeaturesEXT
{
using NativeType = VkPhysicalDeviceRobustness2FeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
}
- operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) &&
- ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRobustness2FeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const &
- physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2FeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2FeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceRobustness2PropertiesEXT
{
using NativeType = VkPhysicalDeviceRobustness2PropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
}
- operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) &&
- ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceRobustness2PropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const &
- physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2PropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2PropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
- seed,
- physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
- seed,
- physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSampleLocationsPropertiesEXT
{
using NativeType = VkPhysicalDeviceSampleLocationsPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ sampleLocationSampleCounts,
+ maxSampleLocationGridSize,
+ sampleLocationCoordinateRange,
+ sampleLocationSubPixelBits,
+ variableSampleLocations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) &&
- ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) &&
- ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) &&
- ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) &&
- ( variableSampleLocations == rhs.variableSampleLocations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSampleLocationsPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const &
- physicalDeviceSampleLocationsPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSampleLocationsPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSampleLocationsPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags,
- seed,
- physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE(
- float, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSamplerFilterMinmaxProperties
{
using NativeType = VkPhysicalDeviceSamplerFilterMinmaxProperties;
return *this;
}
- operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties *>( this );
}
- operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) &&
- ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const &
- physicalDeviceSamplerFilterMinmaxProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerFilterMinmaxProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerFilterMinmaxProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSamplerYcbcrConversionFeatures
{
using NativeType = VkPhysicalDeviceSamplerYcbcrConversionFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>( this );
}
- operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, samplerYcbcrConversion );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const &
- physicalDeviceSamplerYcbcrConversionFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerYcbcrConversionFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceScalarBlockLayoutFeatures
{
using NativeType = VkPhysicalDeviceScalarBlockLayoutFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>( this );
}
- operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, scalarBlockLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const &
- physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceScalarBlockLayoutFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceScalarBlockLayoutFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures
{
using NativeType = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>( this );
}
- operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, separateDepthStencilLayouts );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const &
- physicalDeviceSeparateDepthStencilLayoutsFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT
{
using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>( this );
}
- operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ shaderBufferFloat16Atomics,
+ shaderBufferFloat16AtomicAdd,
+ shaderBufferFloat16AtomicMinMax,
+ shaderBufferFloat32AtomicMinMax,
+ shaderBufferFloat64AtomicMinMax,
+ shaderSharedFloat16Atomics,
+ shaderSharedFloat16AtomicAdd,
+ shaderSharedFloat16AtomicMinMax,
+ shaderSharedFloat32AtomicMinMax,
+ shaderSharedFloat64AtomicMinMax,
+ shaderImageFloat32AtomicMinMax,
+ sparseImageFloat32AtomicMinMax );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) &&
- ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) &&
- ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) &&
- ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) &&
- ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) &&
- ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) &&
- ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) &&
- ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) &&
- ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) &&
- ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) &&
- ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) &&
- ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const &
- physicalDeviceShaderAtomicFloat2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderAtomicFloatFeaturesEXT
{
using NativeType = VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ shaderBufferFloat32Atomics,
+ shaderBufferFloat32AtomicAdd,
+ shaderBufferFloat64Atomics,
+ shaderBufferFloat64AtomicAdd,
+ shaderSharedFloat32Atomics,
+ shaderSharedFloat32AtomicAdd,
+ shaderSharedFloat64Atomics,
+ shaderSharedFloat64AtomicAdd,
+ shaderImageFloat32Atomics,
+ shaderImageFloat32AtomicAdd,
+ sparseImageFloat32Atomics,
+ sparseImageFloat32AtomicAdd );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) &&
- ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) &&
- ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) &&
- ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) &&
- ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) &&
- ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) &&
- ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) &&
- ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) &&
- ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) &&
- ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) &&
- ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) &&
- ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const &
- physicalDeviceShaderAtomicFloatFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderAtomicInt64Features
{
using NativeType = VkPhysicalDeviceShaderAtomicInt64Features;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>( this );
}
- operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) &&
- ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const &
- physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicInt64Features.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicInt64Features.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderClockFeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderClockFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) &&
- ( shaderDeviceClock == rhs.shaderDeviceClock );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderClockFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const &
- physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderClockFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderClockFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderCoreProperties2AMD
{
using NativeType = VkPhysicalDeviceShaderCoreProperties2AMD;
return *this;
}
- operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>( this );
}
- operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) &&
- ( activeComputeUnitCount == rhs.activeComputeUnitCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderCoreProperties2AMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const &
- physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCoreProperties2AMD.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCoreProperties2AMD.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD,
- seed,
- physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderCorePropertiesAMD
{
using NativeType = VkPhysicalDeviceShaderCorePropertiesAMD;
return *this;
}
- operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>( this );
}
- operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ shaderEngineCount,
+ shaderArraysPerEngineCount,
+ computeUnitsPerShaderArray,
+ simdPerComputeUnit,
+ wavefrontsPerSimd,
+ wavefrontSize,
+ sgprsPerSimd,
+ minSgprAllocation,
+ maxSgprAllocation,
+ sgprAllocationGranularity,
+ vgprsPerSimd,
+ minVgprAllocation,
+ maxVgprAllocation,
+ vgprAllocationGranularity );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderCorePropertiesAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const &
- physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCorePropertiesAMD.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCorePropertiesAMD.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
{
using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderDemoteToHelperInvocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &
- physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderDrawParametersFeatures
{
using NativeType = VkPhysicalDeviceShaderDrawParametersFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>( this );
}
- operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderDrawParameters );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const &
- physicalDeviceShaderDrawParametersFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDrawParametersFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDrawParametersFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderFloat16Int8Features
{
using NativeType = VkPhysicalDeviceShaderFloat16Int8Features;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>( this );
}
- operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderFloat16, shaderInt8 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) &&
- ( shaderInt8 == rhs.shaderInt8 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const &
- physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderFloat16Int8Features.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderFloat16Int8Features.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
{
using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>( this );
}
- operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) &&
- ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &
- physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderImageFootprintFeaturesNV
{
using NativeType = VkPhysicalDeviceShaderImageFootprintFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>( this );
}
- operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageFootprint );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderImageFootprintFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const &
- physicalDeviceShaderImageFootprintFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageFootprintFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderIntegerDotProduct );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR const &
- physicalDeviceShaderIntegerDotProductFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.shaderIntegerDotProduct );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR
{
using NativeType = VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *>( this );
}
- operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ integerDotProduct8BitUnsignedAccelerated,
+ integerDotProduct8BitSignedAccelerated,
+ integerDotProduct8BitMixedSignednessAccelerated,
+ integerDotProduct4x8BitPackedUnsignedAccelerated,
+ integerDotProduct4x8BitPackedSignedAccelerated,
+ integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+ integerDotProduct16BitUnsignedAccelerated,
+ integerDotProduct16BitSignedAccelerated,
+ integerDotProduct16BitMixedSignednessAccelerated,
+ integerDotProduct32BitUnsignedAccelerated,
+ integerDotProduct32BitSignedAccelerated,
+ integerDotProduct32BitMixedSignednessAccelerated,
+ integerDotProduct64BitUnsignedAccelerated,
+ integerDotProduct64BitSignedAccelerated,
+ integerDotProduct64BitMixedSignednessAccelerated,
+ integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+ integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+ integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+ integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+ integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+ integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+ integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+ integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+ integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+ integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+ integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+ integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+ integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+ integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+ integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) &&
- ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) &&
- ( integerDotProduct8BitMixedSignednessAccelerated ==
- rhs.integerDotProduct8BitMixedSignednessAccelerated ) &&
- ( integerDotProduct4x8BitPackedUnsignedAccelerated ==
- rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) &&
- ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) &&
- ( integerDotProduct4x8BitPackedMixedSignednessAccelerated ==
- rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) &&
- ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) &&
- ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) &&
- ( integerDotProduct16BitMixedSignednessAccelerated ==
- rhs.integerDotProduct16BitMixedSignednessAccelerated ) &&
- ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) &&
- ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) &&
- ( integerDotProduct32BitMixedSignednessAccelerated ==
- rhs.integerDotProduct32BitMixedSignednessAccelerated ) &&
- ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) &&
- ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) &&
- ( integerDotProduct64BitMixedSignednessAccelerated ==
- rhs.integerDotProduct64BitMixedSignednessAccelerated ) &&
- ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating8BitSignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ==
- rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) &&
- ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ==
- rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) &&
- ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating16BitSignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ==
- rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) &&
- ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating32BitSignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ==
- rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) &&
- ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating64BitSignedAccelerated ==
- rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) &&
- ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ==
- rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR const &
- physicalDeviceShaderIntegerDotProductPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating8BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProductAccumulatingSaturating8BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating16BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating16BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating32BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating32BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating64BitUnsignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating64BitSignedAccelerated );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderIntegerDotProductPropertiesKHR
- .integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
{
using NativeType = VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>( this );
}
- operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderIntegerFunctions2 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &
- physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
{
using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>( this );
}
- operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderSMBuiltins );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const &
- physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
{
using NativeType = VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
return *this;
}
- operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>( this );
}
- operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) &&
- ( shaderWarpsPerSM == rhs.shaderWarpsPerSM );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const &
- physicalDeviceShaderSMBuiltinsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures
{
using NativeType = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>( this );
}
- operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderSubgroupExtendedTypes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const &
- physicalDeviceShaderSubgroupExtendedTypesFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderSubgroupUniformControlFlow );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
- physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderTerminateInvocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderTerminateInvocation == rhs.shaderTerminateInvocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR const &
- physicalDeviceShaderTerminateInvocationFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceShaderTerminateInvocationFeaturesKHR.shaderTerminateInvocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShadingRateImageFeaturesNV
{
using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>( this );
}
- operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) &&
- ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShadingRateImageFeaturesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const &
- physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImageFeaturesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImageFeaturesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceShadingRateImagePropertiesNV
{
using NativeType = VkPhysicalDeviceShadingRateImagePropertiesNV;
return *this;
}
- operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>( this );
}
- operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default;
#else
bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) &&
- ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) &&
- ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceShadingRateImagePropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const &
- physicalDeviceShadingRateImagePropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImagePropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImagePropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSparseImageFormatInfo2
{
using NativeType = VkPhysicalDeviceSparseImageFormatInfo2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( this );
}
- operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::ImageType const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::ImageTiling const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, format, type, samples, usage, tiling );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default;
#else
bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) &&
- ( samples == rhs.samples ) && ( usage == rhs.usage ) && ( tiling == rhs.tiling );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const &
- physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSparseImageFormatInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSparseImageFormatInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceSparseImageFormatInfo2.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceSparseImageFormatInfo2.type );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, physicalDeviceSparseImageFormatInfo2.samples );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceSparseImageFormatInfo2.usage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceSparseImageFormatInfo2.tiling );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSubgroupProperties
{
using NativeType = VkPhysicalDeviceSubgroupProperties;
return *this;
}
- operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>( this );
}
- operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+ VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) &&
- ( supportedStages == rhs.supportedStages ) && ( supportedOperations == rhs.supportedOperations ) &&
- ( quadOperationsInAllStages == rhs.quadOperationsInAllStages );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSubgroupProperties;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupProperties.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupProperties.subgroupSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceSubgroupProperties.supportedStages );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceSubgroupProperties.supportedOperations );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
{
using NativeType = VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) &&
- ( computeFullSubgroups == rhs.computeFullSubgroups );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT const &
- physicalDeviceSubgroupSizeControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.subgroupSizeControl );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.computeFullSubgroups );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
{
using NativeType = VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) &&
- ( maxSubgroupSize == rhs.maxSubgroupSize ) &&
- ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) &&
- ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT const &
- physicalDeviceSubgroupSizeControlPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.minSubgroupSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxSubgroupSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxComputeWorkgroupSubgroups );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags,
- seed,
- physicalDeviceSubgroupSizeControlPropertiesEXT.requiredSubgroupSizeStages );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSubpassShadingFeaturesHUAWEI
{
using NativeType = VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>( this );
}
- operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, subpassShading );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default;
#else
bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const &
- physicalDeviceSubpassShadingFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSubpassShadingPropertiesHUAWEI
{
using NativeType = VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;
return *this;
}
- operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>( this );
}
- operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default;
#else
bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const &
- physicalDeviceSubpassShadingPropertiesHUAWEI ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSurfaceInfo2KHR
{
using NativeType = VkPhysicalDeviceSurfaceInfo2KHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( this );
}
- operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::SurfaceKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, surface );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default;
#else
bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSurfaceInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSurfaceInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSurfaceInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, physicalDeviceSurfaceInfo2KHR.surface );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceSynchronization2FeaturesKHR
{
using NativeType = VkPhysicalDeviceSynchronization2FeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR *>( this );
}
- operator VkPhysicalDeviceSynchronization2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceSynchronization2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, synchronization2 );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceSynchronization2FeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceSynchronization2FeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR const &
- physicalDeviceSynchronization2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSynchronization2FeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSynchronization2FeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSynchronization2FeaturesKHR.synchronization2 );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
{
using NativeType = VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, texelBufferAlignment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const &
- physicalDeviceTexelBufferAlignmentFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
{
using NativeType = VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ storageTexelBufferOffsetAlignmentBytes,
+ storageTexelBufferOffsetSingleTexelAlignment,
+ uniformTexelBufferOffsetAlignmentBytes,
+ uniformTexelBufferOffsetSingleTexelAlignment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) &&
- ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) &&
- ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) &&
- ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const &
- physicalDeviceTexelBufferAlignmentPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
- seed,
- physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetAlignmentBytes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetSingleTexelAlignment );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
- seed,
- physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetAlignmentBytes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetSingleTexelAlignment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
{
using NativeType = VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, textureCompressionASTC_HDR );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &
- physicalDeviceTextureCompressionASTCHDRFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTimelineSemaphoreFeatures
{
using NativeType = VkPhysicalDeviceTimelineSemaphoreFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>( this );
}
- operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, timelineSemaphore );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const &
- physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTimelineSemaphoreProperties
{
using NativeType = VkPhysicalDeviceTimelineSemaphoreProperties;
return *this;
}
- operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties *>( this );
}
- operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default;
#else
bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const &
- physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint64_t, seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceToolPropertiesEXT
{
using NativeType = VkPhysicalDeviceToolPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceToolPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceToolPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceToolPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceToolPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceToolPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, name, version, purposes, description, layer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceToolPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) &&
- ( purposes == rhs.purposes ) && ( description == rhs.description ) && ( layer == rhs.layer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceToolPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT const & physicalDeviceToolPropertiesEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceToolPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceToolPropertiesEXT.pNext );
- for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.name[i] );
- }
- for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.version[i] );
- }
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT, seed, physicalDeviceToolPropertiesEXT.purposes );
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.description[i] );
- }
- for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.layer[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTransformFeedbackFeaturesEXT
{
using NativeType = VkPhysicalDeviceTransformFeedbackFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, transformFeedback, geometryStreams );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) &&
- ( geometryStreams == rhs.geometryStreams );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceTransformFeedbackFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const &
- physicalDeviceTransformFeedbackFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceTransformFeedbackPropertiesEXT
{
using NativeType = VkPhysicalDeviceTransformFeedbackPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ maxTransformFeedbackStreams,
+ maxTransformFeedbackBuffers,
+ maxTransformFeedbackBufferSize,
+ maxTransformFeedbackStreamDataSize,
+ maxTransformFeedbackBufferDataSize,
+ maxTransformFeedbackBufferDataStride,
+ transformFeedbackQueries,
+ transformFeedbackStreamsLinesTriangles,
+ transformFeedbackRasterizationStreamSelect,
+ transformFeedbackDraw );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceTransformFeedbackPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const &
- physicalDeviceTransformFeedbackPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize,
- seed,
- physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceUniformBufferStandardLayoutFeatures
{
using NativeType = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>( this );
}
- operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, uniformBufferStandardLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const &
- physicalDeviceUniformBufferStandardLayoutFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVariablePointersFeatures
{
using NativeType = VkPhysicalDeviceVariablePointersFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>( this );
}
- operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) &&
- ( variablePointers == rhs.variablePointers );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const &
- physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVariablePointersFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVariablePointersFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointers );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
{
using NativeType = VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) &&
- ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const &
- physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
{
using NativeType = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
return *this;
}
- operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>( this );
}
- operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxVertexAttribDivisor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const &
- physicalDeviceVertexAttributeDivisorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT
{
using NativeType = VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, vertexInputDynamicState );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( vertexInputDynamicState == rhs.vertexInputDynamicState );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const &
- physicalDeviceVertexInputDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoProfileKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoProfileKHR *>( this );
}
- operator VkVideoProfileKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoProfileKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoProfileKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoProfileKHR const & ) const = default;
# else
bool operator==( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) &&
- ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) &&
- ( chromaBitDepth == rhs.chromaBitDepth );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoProfileKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoProfileKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileKHR const & videoProfileKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfileKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfileKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR, seed, videoProfileKHR.videoCodecOperation );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR, seed, videoProfileKHR.chromaSubsampling );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.lumaBitDepth );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.chromaBitDepth );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoProfilesKHR *>( this );
}
- operator VkVideoProfilesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoProfilesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoProfilesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoProfileKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, profileCount, pProfiles );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoProfilesKHR const & ) const = default;
# else
bool operator==( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) &&
- ( pProfiles == rhs.pProfiles );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoProfilesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoProfilesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfilesKHR const & videoProfilesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfilesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfilesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoProfilesKHR.profileCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoProfilesKHR.pProfiles );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
return *this;
}
- operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( this );
}
- operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ const VULKAN_HPP_NAMESPACE::VideoProfilesKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageUsage, pVideoProfiles );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default;
# else
bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ) &&
- ( pVideoProfiles == rhs.pVideoProfiles );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = PhysicalDeviceVideoFormatInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVideoFormatInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVideoFormatInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceVideoFormatInfoKHR.imageUsage );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoProfilesKHR *, seed, physicalDeviceVideoFormatInfoKHR.pVideoProfiles );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
struct PhysicalDeviceVulkan11Features
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>( this );
}
- operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVulkan11Features *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ storageBuffer16BitAccess,
+ uniformAndStorageBuffer16BitAccess,
+ storagePushConstant16,
+ storageInputOutput16,
+ multiview,
+ multiviewGeometryShader,
+ multiviewTessellationShader,
+ variablePointersStorageBuffer,
+ variablePointers,
+ protectedMemory,
+ samplerYcbcrConversion,
+ shaderDrawParameters );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default;
#else
bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVulkan11Features;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Features.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Features.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storagePushConstant16 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageInputOutput16 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiview );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewGeometryShader );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewTessellationShader );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointers );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.protectedMemory );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.samplerYcbcrConversion );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.shaderDrawParameters );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVulkan11Properties
{
using NativeType = VkPhysicalDeviceVulkan11Properties;
return *this;
}
- operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkan11Properties *>( this );
}
- operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+ VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::PointClippingBehavior const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ deviceUUID,
+ driverUUID,
+ deviceLUID,
+ deviceNodeMask,
+ deviceLUIDValid,
+ subgroupSize,
+ subgroupSupportedStages,
+ subgroupSupportedOperations,
+ subgroupQuadOperationsInAllStages,
+ pointClippingBehavior,
+ maxMultiviewViewCount,
+ maxMultiviewInstanceIndex,
+ protectedNoFault,
+ maxPerSetDescriptors,
+ maxMemoryAllocationSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default;
#else
bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) &&
- ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVulkan11Properties;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Properties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Properties.pNext );
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceUUID[i] );
- }
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.driverUUID[i] );
- }
- for ( size_t i = 0; i < VK_LUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceLUID[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.deviceNodeMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.deviceLUIDValid );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.subgroupSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedStages );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDeviceVulkan11Properties.pointClippingBehavior );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.protectedNoFault );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVulkan12Features
{
using NativeType = VkPhysicalDeviceVulkan12Features;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>( this );
}
- operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVulkan12Features *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ samplerMirrorClampToEdge,
+ drawIndirectCount,
+ storageBuffer8BitAccess,
+ uniformAndStorageBuffer8BitAccess,
+ storagePushConstant8,
+ shaderBufferInt64Atomics,
+ shaderSharedInt64Atomics,
+ shaderFloat16,
+ shaderInt8,
+ descriptorIndexing,
+ shaderInputAttachmentArrayDynamicIndexing,
+ shaderUniformTexelBufferArrayDynamicIndexing,
+ shaderStorageTexelBufferArrayDynamicIndexing,
+ shaderUniformBufferArrayNonUniformIndexing,
+ shaderSampledImageArrayNonUniformIndexing,
+ shaderStorageBufferArrayNonUniformIndexing,
+ shaderStorageImageArrayNonUniformIndexing,
+ shaderInputAttachmentArrayNonUniformIndexing,
+ shaderUniformTexelBufferArrayNonUniformIndexing,
+ shaderStorageTexelBufferArrayNonUniformIndexing,
+ descriptorBindingUniformBufferUpdateAfterBind,
+ descriptorBindingSampledImageUpdateAfterBind,
+ descriptorBindingStorageImageUpdateAfterBind,
+ descriptorBindingStorageBufferUpdateAfterBind,
+ descriptorBindingUniformTexelBufferUpdateAfterBind,
+ descriptorBindingStorageTexelBufferUpdateAfterBind,
+ descriptorBindingUpdateUnusedWhilePending,
+ descriptorBindingPartiallyBound,
+ descriptorBindingVariableDescriptorCount,
+ runtimeDescriptorArray,
+ samplerFilterMinmax,
+ scalarBlockLayout,
+ imagelessFramebuffer,
+ uniformBufferStandardLayout,
+ shaderSubgroupExtendedTypes,
+ separateDepthStencilLayouts,
+ hostQueryReset,
+ timelineSemaphore,
+ bufferDeviceAddress,
+ bufferDeviceAddressCaptureReplay,
+ bufferDeviceAddressMultiDevice,
+ vulkanMemoryModel,
+ vulkanMemoryModelDeviceScope,
+ vulkanMemoryModelAvailabilityVisibilityChains,
+ shaderOutputViewportIndex,
+ shaderOutputLayer,
+ subgroupBroadcastDynamicId );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default;
#else
bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVulkan12Features;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Features.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Features.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.drawIndirectCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storagePushConstant8 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderFloat16 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInt8 );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.runtimeDescriptorArray );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerFilterMinmax );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.scalarBlockLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.imagelessFramebuffer );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.hostQueryReset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.timelineSemaphore );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddress );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputLayer );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVulkan12Properties
{
using NativeType = VkPhysicalDeviceVulkan12Properties;
return *this;
}
- operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkan12Properties *>( this );
}
- operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::DriverId const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ConformanceVersion const &,
+ VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+ VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::SampleCountFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ driverID,
+ driverName,
+ driverInfo,
+ conformanceVersion,
+ denormBehaviorIndependence,
+ roundingModeIndependence,
+ shaderSignedZeroInfNanPreserveFloat16,
+ shaderSignedZeroInfNanPreserveFloat32,
+ shaderSignedZeroInfNanPreserveFloat64,
+ shaderDenormPreserveFloat16,
+ shaderDenormPreserveFloat32,
+ shaderDenormPreserveFloat64,
+ shaderDenormFlushToZeroFloat16,
+ shaderDenormFlushToZeroFloat32,
+ shaderDenormFlushToZeroFloat64,
+ shaderRoundingModeRTEFloat16,
+ shaderRoundingModeRTEFloat32,
+ shaderRoundingModeRTEFloat64,
+ shaderRoundingModeRTZFloat16,
+ shaderRoundingModeRTZFloat32,
+ shaderRoundingModeRTZFloat64,
+ maxUpdateAfterBindDescriptorsInAllPools,
+ shaderUniformBufferArrayNonUniformIndexingNative,
+ shaderSampledImageArrayNonUniformIndexingNative,
+ shaderStorageBufferArrayNonUniformIndexingNative,
+ shaderStorageImageArrayNonUniformIndexingNative,
+ shaderInputAttachmentArrayNonUniformIndexingNative,
+ robustBufferAccessUpdateAfterBind,
+ quadDivergentImplicitLod,
+ maxPerStageDescriptorUpdateAfterBindSamplers,
+ maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ maxPerStageDescriptorUpdateAfterBindSampledImages,
+ maxPerStageDescriptorUpdateAfterBindStorageImages,
+ maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ maxPerStageUpdateAfterBindResources,
+ maxDescriptorSetUpdateAfterBindSamplers,
+ maxDescriptorSetUpdateAfterBindUniformBuffers,
+ maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ maxDescriptorSetUpdateAfterBindStorageBuffers,
+ maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ maxDescriptorSetUpdateAfterBindSampledImages,
+ maxDescriptorSetUpdateAfterBindStorageImages,
+ maxDescriptorSetUpdateAfterBindInputAttachments,
+ supportedDepthResolveModes,
+ supportedStencilResolveModes,
+ independentResolveNone,
+ independentResolve,
+ filterMinmaxSingleComponentFormats,
+ filterMinmaxImageComponentMapping,
+ maxTimelineSemaphoreValueDifference,
+ framebufferIntegerColorSampleCounts );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default;
#else
bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) &&
- ( driverName == rhs.driverName ) && ( driverInfo == rhs.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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceVulkan12Properties;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Properties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Properties.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceVulkan12Properties.driverID );
- for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverName[i] );
- }
- for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverInfo[i] );
- }
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceVulkan12Properties.conformanceVersion );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
- seed,
- physicalDeviceVulkan12Properties.denormBehaviorIndependence );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence,
- seed,
- physicalDeviceVulkan12Properties.roundingModeIndependence );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolveNone );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolve );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags,
- seed,
- physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceVulkanMemoryModelFeatures
{
using NativeType = VkPhysicalDeviceVulkanMemoryModelFeatures;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>( this );
}
- operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default;
#else
bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) &&
- ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) &&
- ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const &
- physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkanMemoryModelFeatures.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkanMemoryModelFeatures.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
{
using NativeType = VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ workgroupMemoryExplicitLayout,
+ workgroupMemoryExplicitLayoutScalarBlockLayout,
+ workgroupMemoryExplicitLayout8BitAccess,
+ workgroupMemoryExplicitLayout16BitAccess );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) &&
- ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) &&
- ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) &&
- ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
- physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
{
using NativeType = VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, ycbcr2plane444Formats );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &
- physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
{
using NativeType = VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>( this );
}
- operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, ycbcrImageArrays );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const &
- physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
{
using NativeType = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>( this );
}
- operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &
- physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.shaderZeroInitializeWorkgroupMemory );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCacheCreateInfo
{
using NativeType = VkPipelineCacheCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCacheCreateInfo *>( this );
}
- operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCacheCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags const &,
+ size_t const &,
+ const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCacheCreateInfo const & ) const = default;
#else
bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineCacheCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCacheCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags, seed, pipelineCacheCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineCacheCreateInfo.initialDataSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pInitialData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCacheHeaderVersionOne
{
using NativeType = VkPipelineCacheHeaderVersionOne;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCacheHeaderVersionOne *>( this );
}
- operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCacheHeaderVersionOne *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default;
#else
bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) &&
- ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) &&
- ( pipelineCacheUUID == rhs.pipelineCacheUUID );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>::value,
"PipelineCacheHeaderVersionOne is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.headerSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion, seed, pipelineCacheHeaderVersionOne.headerVersion );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.vendorID );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.deviceID );
- for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineColorBlendAdvancedStateCreateInfoEXT
{
using NativeType = VkPipelineColorBlendAdvancedStateCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>( this );
}
- operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::BlendOverlapEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) &&
- ( dstPremultiplied == rhs.dstPremultiplied ) && ( blendOverlap == rhs.blendOverlap );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineColorBlendAdvancedStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const &
- pipelineColorBlendAdvancedStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::BlendOverlapEXT, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineColorWriteCreateInfoEXT
{
using NativeType = VkPipelineColorWriteCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT *>( this );
}
- operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineColorWriteCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Bool32 * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, attachmentCount, pColorWriteEnables );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) &&
- ( pColorWriteEnables == rhs.pColorWriteEnables );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineColorWriteCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorWriteCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorWriteCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorWriteCreateInfoEXT.attachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Bool32 *, seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCompilerControlCreateInfoAMD
{
using NativeType = VkPipelineCompilerControlCreateInfoAMD;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>( this );
}
- operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, compilerControlFlags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default;
#else
bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineCompilerControlCreateInfoAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const &
- pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCompilerControlCreateInfoAMD.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCompilerControlCreateInfoAMD.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD,
- seed,
- pipelineCompilerControlCreateInfoAMD.compilerControlFlags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCoverageModulationStateCreateInfoNV
{
using NativeType = VkPipelineCoverageModulationStateCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>( this );
}
- operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::CoverageModulationModeNV const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ const float * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ coverageModulationMode,
+ coverageModulationTableEnable,
+ coverageModulationTableCount,
+ pCoverageModulationTable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( coverageModulationMode == rhs.coverageModulationMode ) &&
- ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) &&
- ( coverageModulationTableCount == rhs.coverageModulationTableCount ) &&
- ( pCoverageModulationTable == rhs.pCoverageModulationTable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineCoverageModulationStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const &
- pipelineCoverageModulationStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageModulationStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageModulationStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV,
- seed,
- pipelineCoverageModulationStateCreateInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV,
- seed,
- pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount );
- VULKAN_HPP_HASH_COMBINE(
- const float *, seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCoverageReductionStateCreateInfoNV
{
using NativeType = VkPipelineCoverageReductionStateCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>( this );
}
- operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::CoverageReductionModeNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, coverageReductionMode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( coverageReductionMode == rhs.coverageReductionMode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineCoverageReductionStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const &
- pipelineCoverageReductionStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageReductionStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageReductionStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV,
- seed,
- pipelineCoverageReductionStateCreateInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV,
- seed,
- pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCoverageToColorStateCreateInfoNV
{
using NativeType = VkPipelineCoverageToColorStateCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>( this );
}
- operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( coverageToColorEnable == rhs.coverageToColorEnable ) &&
- ( coverageToColorLocation == rhs.coverageToColorLocation );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineCoverageToColorStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const &
- pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageToColorStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageToColorStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV,
- seed,
- pipelineCoverageToColorStateCreateInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCreationFeedbackEXT
{
using NativeType = VkPipelineCreationFeedbackEXT;
return *this;
}
- operator VkPipelineCreationFeedbackEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCreationFeedbackEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCreationFeedbackEXT *>( this );
}
- operator VkPipelineCreationFeedbackEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCreationFeedbackEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCreationFeedbackEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( flags, duration );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCreationFeedbackEXT const & ) const = default;
#else
bool operator==( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( flags == rhs.flags ) && ( duration == rhs.duration );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT>::value,
"PipelineCreationFeedbackEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT const & pipelineCreationFeedbackEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT, seed, pipelineCreationFeedbackEXT.flags );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pipelineCreationFeedbackEXT.duration );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineCreationFeedbackCreateInfoEXT
{
using NativeType = VkPipelineCreationFeedbackCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT *>( this );
}
- operator VkPipelineCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) &&
- ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) &&
- ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineCreationFeedbackCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT const &
- pipelineCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCreationFeedbackCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCreationFeedbackCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *,
- seed,
- pipelineCreationFeedbackCreateInfoEXT.pPipelineCreationFeedback );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCreationFeedbackCreateInfoEXT.pipelineStageCreationFeedbackCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *,
- seed,
- pipelineCreationFeedbackCreateInfoEXT.pPipelineStageCreationFeedbacks );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineDiscardRectangleStateCreateInfoEXT
{
using NativeType = VkPipelineDiscardRectangleStateCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>( this );
}
- operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( discardRectangleMode == rhs.discardRectangleMode ) &&
- ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineDiscardRectangleStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const &
- pipelineDiscardRectangleStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDiscardRectangleStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT,
- seed,
- pipelineDiscardRectangleStateCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT,
- seed,
- pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineExecutableInfoKHR
{
using NativeType = VkPipelineExecutableInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineExecutableInfoKHR *>( this );
}
- operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineExecutableInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pipeline, executableIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineExecutableInfoKHR const & ) const = default;
#else
bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) &&
- ( executableIndex == rhs.executableIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineExecutableInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineExecutableInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineExecutableInfoKHR.pipeline );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutableInfoKHR.executableIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineExecutableInternalRepresentationKHR
{
using NativeType = VkPipelineExecutableInternalRepresentationKHR;
return *this;
}
- operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR *>( this );
}
- operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ size_t const &,
+ void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, name, description, isText, dataSize, pData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default;
#else
bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) &&
- ( description == rhs.description ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) &&
- ( pData == rhs.pData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineExecutableInternalRepresentationKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const &
- pipelineExecutableInternalRepresentationKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInternalRepresentationKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pNext );
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.name[i] );
- }
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.description[i] );
- }
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineExecutableInternalRepresentationKHR.isText );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineExecutableInternalRepresentationKHR.dataSize );
- VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineExecutablePropertiesKHR
{
using NativeType = VkPipelineExecutablePropertiesKHR;
return *this;
}
- operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineExecutablePropertiesKHR *>( this );
}
- operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stages, name, description, subgroupSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default;
#else
bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) &&
- ( description == rhs.description ) && ( subgroupSize == rhs.subgroupSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineExecutablePropertiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutablePropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutablePropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pipelineExecutablePropertiesKHR.stages );
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.name[i] );
- }
- for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.description[i] );
- }
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutablePropertiesKHR.subgroupSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
union PipelineExecutableStatisticValueKHR
{
using NativeType = VkPipelineExecutableStatisticValueKHR;
return *this;
}
- operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineExecutableStatisticKHR *>( this );
}
- operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineExecutableStatisticKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
+ VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR const &,
+ VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, name, description, format, value );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>( this );
}
- operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV const &,
+ VULKAN_HPP_NAMESPACE::FragmentShadingRateNV const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, 2> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default;
#else
- bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) &&
- ( shadingRate == rhs.shadingRate ) && ( combinerOps == rhs.combinerOps );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const &
- pipelineFragmentShadingRateEnumStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV,
- seed,
- pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FragmentShadingRateNV, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR,
- seed,
- pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineFragmentShadingRateStateCreateInfoKHR
{
using NativeType = VkPipelineFragmentShadingRateStateCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR *>( this );
}
- operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, 2> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentSize, combinerOps );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default;
#else
bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) &&
- ( combinerOps == rhs.combinerOps );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineFragmentShadingRateStateCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const &
- pipelineFragmentShadingRateStateCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize );
- for ( size_t i = 0; i < 2; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR,
- seed,
- pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineInfoKHR
{
using NativeType = VkPipelineInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineInfoKHR *>( this );
}
- operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Pipeline const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pipeline );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineInfoKHR const & ) const = default;
#else
bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineInfoKHR.pipeline );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PushConstantRange
{
using NativeType = VkPushConstantRange;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPushConstantRange *>( this );
}
- operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPushConstantRange *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ShaderStageFlags const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( stageFlags, offset, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PushConstantRange const & ) const = default;
#else
bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PushConstantRange>::value,
"PushConstantRange is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pushConstantRange.stageFlags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.offset );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineLayoutCreateInfo
{
using NativeType = VkPipelineLayoutCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineLayoutCreateInfo *>( this );
}
- operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineLayoutCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PushConstantRange * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineLayoutCreateInfo const & ) const = default;
#else
bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ) &&
- ( pushConstantRangeCount == rhs.pushConstantRangeCount ) &&
- ( pPushConstantRanges == rhs.pPushConstantRanges );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineLayoutCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLayoutCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLayoutCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags, seed, pipelineLayoutCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.setLayoutCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, pipelineLayoutCreateInfo.pSetLayouts );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.pushConstantRangeCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PushConstantRange *, seed, pipelineLayoutCreateInfo.pPushConstantRanges );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineLibraryCreateInfoKHR
{
using NativeType = VkPipelineLibraryCreateInfoKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineLibraryCreateInfoKHR *>( this );
}
- operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineLibraryCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Pipeline * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, libraryCount, pLibraries );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default;
#else
bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) &&
- ( pLibraries == rhs.pLibraries );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineLibraryCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLibraryCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLibraryCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLibraryCreateInfoKHR.libraryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Pipeline *, seed, pipelineLibraryCreateInfoKHR.pLibraries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationConservativeStateCreateInfoEXT
{
using NativeType = VkPipelineRasterizationConservativeStateCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>( this );
}
- operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT const &,
+ float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) &&
- ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationConservativeStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const &
- pipelineRasterizationConservativeStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT,
- seed,
- pipelineRasterizationConservativeStateCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT,
- seed,
- pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode );
- VULKAN_HPP_HASH_COMBINE(
- float, seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationDepthClipStateCreateInfoEXT
{
using NativeType = VkPipelineRasterizationDepthClipStateCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>( this );
}
- operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, depthClipEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( depthClipEnable == rhs.depthClipEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationDepthClipStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const &
- pipelineRasterizationDepthClipStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT,
- seed,
- pipelineRasterizationDepthClipStateCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationLineStateCreateInfoEXT
{
using NativeType = VkPipelineRasterizationLineStateCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
}
- operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint16_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( lineRasterizationMode == rhs.lineRasterizationMode ) &&
- ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) &&
- ( lineStipplePattern == rhs.lineStipplePattern );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationLineStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const &
- pipelineRasterizationLineStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT,
- seed,
- pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
- VULKAN_HPP_HASH_COMBINE( uint16_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationProvokingVertexStateCreateInfoEXT
{
using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>( this );
}
- operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, provokingVertexMode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
- pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT,
- seed,
- pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationStateRasterizationOrderAMD
{
using NativeType = VkPipelineRasterizationStateRasterizationOrderAMD;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>( this );
}
- operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RasterizationOrderAMD const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, rasterizationOrder );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default;
#else
bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationStateRasterizationOrderAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const &
- pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateRasterizationOrderAMD.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateRasterizationOrderAMD.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD,
- seed,
- pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRasterizationStateStreamCreateInfoEXT
{
using NativeType = VkPipelineRasterizationStateStreamCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>( this );
}
- operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, rasterizationStream );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( rasterizationStream == rhs.rasterizationStream );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRasterizationStateStreamCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const &
- pipelineRasterizationStateStreamCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateStreamCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT,
- seed,
- pipelineRasterizationStateStreamCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRenderingCreateInfoKHR
{
using NativeType = VkPipelineRenderingCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRenderingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRenderingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRenderingCreateInfoKHR *>( this );
}
- operator VkPipelineRenderingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRenderingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRenderingCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Format * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::Format const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ viewMask,
+ colorAttachmentCount,
+ pColorAttachmentFormats,
+ depthAttachmentFormat,
+ stencilAttachmentFormat );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRenderingCreateInfoKHR const & ) const = default;
#else
bool operator==( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) &&
- ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
- ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
- ( depthAttachmentFormat == rhs.depthAttachmentFormat ) &&
- ( stencilAttachmentFormat == rhs.stencilAttachmentFormat );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRenderingCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR const & pipelineRenderingCreateInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRenderingCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRenderingCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.viewMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.colorAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::Format *, seed, pipelineRenderingCreateInfoKHR.pColorAttachmentFormats );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.depthAttachmentFormat );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.stencilAttachmentFormat );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineRepresentativeFragmentTestStateCreateInfoNV
{
using NativeType = VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>( this );
}
- operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, representativeFragmentTestEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const &
- pipelineRepresentativeFragmentTestStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32,
- seed,
- pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineSampleLocationsStateCreateInfoEXT
{
using NativeType = VkPipelineSampleLocationsStateCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>( this );
}
- operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( sampleLocationsEnable == rhs.sampleLocationsEnable ) &&
- ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineSampleLocationsStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const &
- pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineSampleLocationsStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineSampleLocationsStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT,
- seed,
- pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
{
using NativeType = VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
return *this;
}
- operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>( this );
}
- operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, requiredSubgroupSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &
- pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.requiredSubgroupSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineTessellationDomainOriginStateCreateInfo
{
using NativeType = VkPipelineTessellationDomainOriginStateCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>( this );
}
- operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::TessellationDomainOrigin const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, domainOrigin );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default;
#else
bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const &
- pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationDomainOriginStateCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationDomainOriginStateCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin,
- seed,
- pipelineTessellationDomainOriginStateCreateInfo.domainOrigin );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct VertexInputBindingDivisorDescriptionEXT
{
using NativeType = VkVertexInputBindingDivisorDescriptionEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT *>( this );
}
- operator VkVertexInputBindingDivisorDescriptionEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputBindingDivisorDescriptionEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( binding, divisor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VertexInputBindingDivisorDescriptionEXT const & ) const = default;
#else
bool operator==( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( binding == rhs.binding ) && ( divisor == rhs.divisor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>::value,
"VertexInputBindingDivisorDescriptionEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const &
- vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.binding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.divisor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineVertexInputDivisorStateCreateInfoEXT
{
using NativeType = VkPipelineVertexInputDivisorStateCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT *>( this );
}
- operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) &&
- ( pVertexBindingDivisors == rhs.pVertexBindingDivisors );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineVertexInputDivisorStateCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const &
- pipelineVertexInputDivisorStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT *,
- seed,
- pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
{
using NativeType = VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>( this );
}
- operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) &&
- ( customSampleOrderCount == rhs.customSampleOrderCount ) &&
- ( pCustomSampleOrders == rhs.pCustomSampleOrders );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const &
- pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV,
- seed,
- pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV *,
- seed,
- pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportDepthClipControlCreateInfoEXT
{
using NativeType = VkPipelineViewportDepthClipControlCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT *>( this );
}
- operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, negativeOneToOne );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default;
#else
bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportDepthClipControlCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const &
- pipelineViewportDepthClipControlCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportDepthClipControlCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportExclusiveScissorStateCreateInfoNV
{
using NativeType = VkPipelineViewportExclusiveScissorStateCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>( this );
}
- operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Rect2D * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && ( pExclusiveScissors == rhs.pExclusiveScissors );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportExclusiveScissorStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const &
- pipelineViewportExclusiveScissorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *,
- seed,
- pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ShadingRatePaletteNV
{
using NativeType = VkShadingRatePaletteNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkShadingRatePaletteNV *>( this );
}
- operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkShadingRatePaletteNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ShadingRatePaletteNV const & ) const = default;
#else
bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) &&
- ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>::value,
"ShadingRatePaletteNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shadingRatePaletteNV.shadingRatePaletteEntryCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV *, seed, shadingRatePaletteNV.pShadingRatePaletteEntries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportShadingRateImageStateCreateInfoNV
{
using NativeType = VkPipelineViewportShadingRateImageStateCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>( this );
}
- operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && ( viewportCount == rhs.viewportCount ) &&
- ( pShadingRatePalettes == rhs.pShadingRatePalettes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportShadingRateImageStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const &
- pipelineViewportShadingRateImageStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV *,
- seed,
- pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ViewportSwizzleNV
{
using NativeType = VkViewportSwizzleNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkViewportSwizzleNV *>( this );
}
- operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkViewportSwizzleNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
+ VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
+ VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
+ VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( x, y, z, w );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ViewportSwizzleNV const & ) const = default;
#else
bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>::value,
"ViewportSwizzleNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.x );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.y );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.z );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.w );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportSwizzleStateCreateInfoNV
{
using NativeType = VkPipelineViewportSwizzleStateCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>( this );
}
- operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( viewportCount == rhs.viewportCount ) && ( pViewportSwizzles == rhs.pViewportSwizzles );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportSwizzleStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const &
- pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportSwizzleStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportSwizzleStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV,
- seed,
- pipelineViewportSwizzleStateCreateInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV *,
- seed,
- pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ViewportWScalingNV
{
using NativeType = VkViewportWScalingNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkViewportWScalingNV *>( this );
}
- operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkViewportWScalingNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<float const &, float const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( xcoeff, ycoeff );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ViewportWScalingNV const & ) const = default;
#else
bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>::value,
"ViewportWScalingNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.xcoeff );
- VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.ycoeff );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PipelineViewportWScalingStateCreateInfoNV
{
using NativeType = VkPipelineViewportWScalingStateCreateInfoNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>( this );
}
- operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default;
#else
bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && ( viewportCount == rhs.viewportCount ) &&
- ( pViewportWScalings == rhs.pViewportWScalings );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PipelineViewportWScalingStateCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const &
- pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportWScalingStateCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportWScalingStateCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *,
- seed,
- pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_GGP )
struct PresentFrameTokenGGP
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentFrameTokenGGP *>( this );
}
- operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentFrameTokenGGP *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, GgpFrameToken const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, frameToken );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentFrameTokenGGP const & ) const = default;
# else
bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = PresentFrameTokenGGP;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentFrameTokenGGP.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, presentFrameTokenGGP.pNext );
- VULKAN_HPP_HASH_COMBINE( GgpFrameToken, seed, presentFrameTokenGGP.frameToken );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_GGP*/
struct PresentIdKHR
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentIdKHR *>( this );
}
- operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentIdKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint64_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchainCount, pPresentIds );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentIdKHR const & ) const = default;
#else
bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
- ( pPresentIds == rhs.pPresentIds );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PresentIdKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentIdKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, presentIdKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentIdKHR.swapchainCount );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, presentIdKHR.pPresentIds );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PresentInfoKHR
{
using NativeType = VkPresentInfoKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentInfoKHR *>( this );
}
- operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SwapchainKHR * const &,
+ const uint32_t * const &,
+ VULKAN_HPP_NAMESPACE::Result * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentInfoKHR const & ) const = default;
#else
bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
- ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) &&
- ( pSwapchains == rhs.pSwapchains ) && ( pImageIndices == rhs.pImageIndices ) &&
- ( pResults == rhs.pResults );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PresentInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, presentInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.waitSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, presentInfoKHR.pWaitSemaphores );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.swapchainCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SwapchainKHR *, seed, presentInfoKHR.pSwapchains );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, presentInfoKHR.pImageIndices );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Result *, seed, presentInfoKHR.pResults );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RectLayerKHR
{
using NativeType = VkRectLayerKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRectLayerKHR *>( this );
}
- operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRectLayerKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Offset2D const &, VULKAN_HPP_NAMESPACE::Extent2D const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( offset, extent, layer );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RectLayerKHR const & ) const = default;
#else
bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RectLayerKHR>::value,
"RectLayerKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rectLayerKHR.offset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rectLayerKHR.extent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rectLayerKHR.layer );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PresentRegionKHR
{
using NativeType = VkPresentRegionKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentRegionKHR *>( this );
}
- operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentRegionKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::RectLayerKHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( rectangleCount, pRectangles );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentRegionKHR const & ) const = default;
#else
bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PresentRegionKHR>::value,
"PresentRegionKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionKHR.rectangleCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RectLayerKHR *, seed, presentRegionKHR.pRectangles );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PresentRegionsKHR
{
using NativeType = VkPresentRegionsKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentRegionsKHR *>( this );
}
- operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentRegionsKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PresentRegionKHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchainCount, pRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentRegionsKHR const & ) const = default;
#else
bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
- ( pRegions == rhs.pRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PresentRegionsKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentRegionsKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, presentRegionsKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionsKHR.swapchainCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentRegionKHR *, seed, presentRegionsKHR.pRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PresentTimeGOOGLE
{
using NativeType = VkPresentTimeGOOGLE;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentTimeGOOGLE *>( this );
}
- operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentTimeGOOGLE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( presentID, desiredPresentTime );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentTimeGOOGLE const & ) const = default;
#else
bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>::value,
"PresentTimeGOOGLE is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimeGOOGLE.presentID );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, presentTimeGOOGLE.desiredPresentTime );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PresentTimesInfoGOOGLE
{
using NativeType = VkPresentTimesInfoGOOGLE;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPresentTimesInfoGOOGLE *>( this );
}
- operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPresentTimesInfoGOOGLE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, swapchainCount, pTimes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default;
#else
bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
- ( pTimes == rhs.pTimes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PresentTimesInfoGOOGLE;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentTimesInfoGOOGLE.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, presentTimesInfoGOOGLE.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimesInfoGOOGLE.swapchainCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE *, seed, presentTimesInfoGOOGLE.pTimes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct PrivateDataSlotCreateInfoEXT
{
using NativeType = VkPrivateDataSlotCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( this );
}
- operator VkPrivateDataSlotCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkPrivateDataSlotCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPrivateDataSlotCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PrivateDataSlotCreateInfoEXT const & ) const = default;
#else
bool operator==( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = PrivateDataSlotCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & privateDataSlotCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, privateDataSlotCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, privateDataSlotCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT, seed, privateDataSlotCreateInfoEXT.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ProtectedSubmitInfo
{
using NativeType = VkProtectedSubmitInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkProtectedSubmitInfo *>( this );
}
- operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkProtectedSubmitInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, protectedSubmit );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ProtectedSubmitInfo const & ) const = default;
#else
bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ProtectedSubmitInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, protectedSubmitInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, protectedSubmitInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, protectedSubmitInfo.protectedSubmit );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueryPoolCreateInfo
{
using NativeType = VkQueryPoolCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueryPoolCreateInfo *>( this );
}
- operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueryPoolCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::QueryType const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueryPoolCreateInfo const & ) const = default;
#else
bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) &&
- ( pipelineStatistics == rhs.pipelineStatistics );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = QueryPoolCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags, seed, queryPoolCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryType, seed, queryPoolCreateInfo.queryType );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolCreateInfo.queryCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, queryPoolCreateInfo.pipelineStatistics );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueryPoolPerformanceCreateInfoKHR
{
using NativeType = VkQueryPoolPerformanceCreateInfoKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( this );
}
- operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default;
#else
bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
- ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = QueryPoolPerformanceCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const &
- queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueryPoolPerformanceQueryCreateInfoINTEL
{
using NativeType = VkQueryPoolPerformanceQueryCreateInfoINTEL;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL *>( this );
}
- operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, performanceCountersSampling );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default;
#else
bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( performanceCountersSampling == rhs.performanceCountersSampling );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const &
- queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceQueryCreateInfoINTEL.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL,
- seed,
- queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueueFamilyCheckpointProperties2NV
{
using NativeType = VkQueueFamilyCheckpointProperties2NV;
return *this;
}
- operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>( this );
}
- operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueueFamilyCheckpointProperties2NV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, checkpointExecutionStageMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default;
#else
bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = QueueFamilyCheckpointProperties2NV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const &
- queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointProperties2NV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointProperties2NV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR,
- seed,
- queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueueFamilyCheckpointPropertiesNV
{
using NativeType = VkQueueFamilyCheckpointPropertiesNV;
return *this;
}
- operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>( this );
}
- operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, checkpointExecutionStageMask );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default;
#else
bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = QueueFamilyCheckpointPropertiesNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const &
- queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointPropertiesNV.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointPropertiesNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueueFamilyGlobalPriorityPropertiesEXT
{
using NativeType = VkQueueFamilyGlobalPriorityPropertiesEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT *>( this );
}
- operator VkQueueFamilyGlobalPriorityPropertiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyGlobalPriorityPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT,
+ VK_MAX_GLOBAL_PRIORITY_SIZE_EXT> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, priorityCount, priorities );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueueFamilyGlobalPriorityPropertiesEXT const & ) const = default;
#else
bool operator==( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) &&
- ( priorities == rhs.priorities );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = QueueFamilyGlobalPriorityPropertiesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT const &
- queueFamilyGlobalPriorityPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyGlobalPriorityPropertiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyGlobalPriorityPropertiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyGlobalPriorityPropertiesEXT.priorityCount );
- for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_EXT; ++i )
- {
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, queueFamilyGlobalPriorityPropertiesEXT.priorities[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueueFamilyProperties
{
using NativeType = VkQueueFamilyProperties;
return *this;
}
- operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueueFamilyProperties *>( this );
}
- operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueueFamilyProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::QueueFlags const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueueFamilyProperties const & ) const = default;
#else
bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) &&
- ( timestampValidBits == rhs.timestampValidBits ) &&
- ( minImageTransferGranularity == rhs.minImageTransferGranularity );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
"QueueFamilyProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueueFlags, seed, queueFamilyProperties.queueFlags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.queueCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.timestampValidBits );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, queueFamilyProperties.minImageTransferGranularity );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct QueueFamilyProperties2
{
using NativeType = VkQueueFamilyProperties2;
return *this;
}
- operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkQueueFamilyProperties2 *>( this );
}
- operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkQueueFamilyProperties2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::QueueFamilyProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, queueFamilyProperties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueueFamilyProperties2 const & ) const = default;
#else
bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using QueueFamilyProperties2KHR = QueueFamilyProperties2;
-} // namespace VULKAN_HPP_NAMESPACE
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct QueueFamilyQueryResultStatusProperties2KHR
+ {
+ using NativeType = VkQueueFamilyQueryResultStatusProperties2KHR;
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyProperties2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyProperties2.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::QueueFamilyProperties, seed, queueFamilyProperties2.queueFamilyProperties );
- return seed;
- }
-};
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+ StructureType::eQueueFamilyQueryResultStatusProperties2KHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR
+ QueueFamilyQueryResultStatusProperties2KHR( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT
+ : supported( supported_ )
+ {}
+
+ VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusProperties2KHR(
+ QueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ QueueFamilyQueryResultStatusProperties2KHR( VkQueueFamilyQueryResultStatusProperties2KHR const & rhs )
+ VULKAN_HPP_NOEXCEPT
+ : QueueFamilyQueryResultStatusProperties2KHR(
+ *reinterpret_cast<QueueFamilyQueryResultStatusProperties2KHR const *>( &rhs ) )
+ {}
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ QueueFamilyQueryResultStatusProperties2KHR &
+ operator=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ QueueFamilyQueryResultStatusProperties2KHR &
+ operator=( VkQueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 QueueFamilyQueryResultStatusProperties2KHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 QueueFamilyQueryResultStatusProperties2KHR &
+ setSupported( VULKAN_HPP_NAMESPACE::Bool32 supported_ ) VULKAN_HPP_NOEXCEPT
+ {
+ supported = supported_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ explicit operator VkQueueFamilyQueryResultStatusProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkQueueFamilyQueryResultStatusProperties2KHR *>( this );
+ }
+
+ explicit operator VkQueueFamilyQueryResultStatusProperties2KHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkQueueFamilyQueryResultStatusProperties2KHR *>( this );
+ }
+
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, supported );
+ }
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( QueueFamilyQueryResultStatusProperties2KHR const & ) const = default;
+# else
+ bool operator==( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() == rhs.reflect();
+ }
+
+ bool operator!=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() != rhs.reflect();
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyQueryResultStatusProperties2KHR;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 supported = {};
+ };
+ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR ) ==
+ sizeof( VkQueueFamilyQueryResultStatusProperties2KHR ),
+ "struct and wrapper have different size!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_standard_layout<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR>::value,
+ "struct wrapper is not a standard layout!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR>::value,
+ "QueueFamilyQueryResultStatusProperties2KHR is not nothrow_move_constructible!" );
+
+ template <>
+ struct CppType<StructureType, StructureType::eQueueFamilyQueryResultStatusProperties2KHR>
+ {
+ using Type = QueueFamilyQueryResultStatusProperties2KHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-namespace VULKAN_HPP_NAMESPACE
-{
struct RayTracingShaderGroupCreateInfoKHR
{
using NativeType = VkRayTracingShaderGroupCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR *>( this );
}
- operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ type,
+ generalShader,
+ closestHitShader,
+ anyHitShader,
+ intersectionShader,
+ pShaderGroupCaptureReplayHandle );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default;
#else
bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
- ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) &&
- ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) &&
- ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RayTracingShaderGroupCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const &
- rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoKHR.type );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.generalShader );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RayTracingPipelineInterfaceCreateInfoKHR
{
using NativeType = VkRayTracingPipelineInterfaceCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR *>( this );
}
- operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default;
#else
bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) &&
- ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RayTracingPipelineInterfaceCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const &
- rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineInterfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RayTracingPipelineCreateInfoKHR
{
using NativeType = VkRayTracingPipelineCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( this );
}
- operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRayTracingPipelineCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR * const &,
+ const VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo * const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ stageCount,
+ pStages,
+ groupCount,
+ pGroups,
+ maxPipelineRayRecursionDepth,
+ pLibraryInfo,
+ pLibraryInterface,
+ pDynamicState,
+ layout,
+ basePipelineHandle,
+ basePipelineIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default;
#else
bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) &&
- ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) &&
- ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) &&
- ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) &&
- ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RayTracingPipelineCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.stageCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoKHR.pStages );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.groupCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pGroups );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR *,
- seed,
- rayTracingPipelineCreateInfoKHR.pLibraryInterface );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *,
- seed,
- rayTracingPipelineCreateInfoKHR.pDynamicState );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoKHR.layout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RayTracingShaderGroupCreateInfoNV
{
using NativeType = VkRayTracingShaderGroupCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV *>( this );
}
- operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default;
#else
bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
- ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) &&
- ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RayTracingShaderGroupCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const &
- rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoNV.type );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.generalShader );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.closestHitShader );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.anyHitShader );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.intersectionShader );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RayTracingPipelineCreateInfoNV
{
using NativeType = VkRayTracingPipelineCreateInfoNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( this );
}
- operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::PipelineLayout const &,
+ VULKAN_HPP_NAMESPACE::Pipeline const &,
+ int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ stageCount,
+ pStages,
+ groupCount,
+ pGroups,
+ maxRecursionDepth,
+ layout,
+ basePipelineHandle,
+ basePipelineIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default;
#else
bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RayTracingPipelineCreateInfoNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoNV.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.stageCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoNV.pStages );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.groupCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV *, seed, rayTracingPipelineCreateInfoNV.pGroups );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoNV.layout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoNV.basePipelineHandle );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoNV.basePipelineIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RefreshCycleDurationGOOGLE
{
using NativeType = VkRefreshCycleDurationGOOGLE;
return *this;
}
- operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE *>( this );
}
- operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( refreshDuration );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default;
#else
bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( refreshDuration == rhs.refreshDuration );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::value,
"RefreshCycleDurationGOOGLE is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, refreshCycleDurationGOOGLE.refreshDuration );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassAttachmentBeginInfo
{
using NativeType = VkRenderPassAttachmentBeginInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>( this );
}
- operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassAttachmentBeginInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageView * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, attachmentCount, pAttachments );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default;
#else
bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) &&
- ( pAttachments == rhs.pAttachments );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassAttachmentBeginInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassAttachmentBeginInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassAttachmentBeginInfo.attachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::ImageView *, seed, renderPassAttachmentBeginInfo.pAttachments );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassBeginInfo
{
using NativeType = VkRenderPassBeginInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassBeginInfo *>( this );
}
- operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassBeginInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RenderPass const &,
+ VULKAN_HPP_NAMESPACE::Framebuffer const &,
+ VULKAN_HPP_NAMESPACE::Rect2D const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ClearValue * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassBeginInfo const & ) const = default;
#else
bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
- ( framebuffer == rhs.framebuffer ) && ( renderArea == rhs.renderArea ) &&
- ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderPassBeginInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassBeginInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassBeginInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, renderPassBeginInfo.renderPass );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, renderPassBeginInfo.framebuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderPassBeginInfo.renderArea );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassBeginInfo.clearValueCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ClearValue *, seed, renderPassBeginInfo.pClearValues );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassDescription
{
using NativeType = VkSubpassDescription;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassDescription *>( this );
}
- operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassDescription *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags const &,
+ VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( flags,
+ pipelineBindPoint,
+ inputAttachmentCount,
+ pInputAttachments,
+ colorAttachmentCount,
+ pColorAttachments,
+ pResolveAttachments,
+ pDepthStencilAttachment,
+ preserveAttachmentCount,
+ pPreserveAttachments );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassDescription const & ) const = default;
#else
bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
- ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) &&
- ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
- ( pResolveAttachments == rhs.pResolveAttachments ) &&
- ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) &&
- ( preserveAttachmentCount == rhs.preserveAttachmentCount ) &&
- ( pPreserveAttachments == rhs.pPreserveAttachments );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassDescription>::value,
"SubpassDescription is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription.pipelineBindPoint );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.inputAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pInputAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.colorAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pColorAttachments );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pResolveAttachments );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pDepthStencilAttachment );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.preserveAttachmentCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription.pPreserveAttachments );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassDependency
{
using NativeType = VkSubpassDependency;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassDependency *>( this );
}
- operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassDependency *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::DependencyFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassDependency const & ) const = default;
#else
bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) &&
- ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) &&
- ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) &&
- ( dependencyFlags == rhs.dependencyFlags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassDependency>::value,
"SubpassDependency is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.srcSubpass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.dstSubpass );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.srcStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.dstStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.dstAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency.dependencyFlags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassCreateInfo
{
using NativeType = VkRenderPassCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassCreateInfo *>( this );
}
- operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RenderPassCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentDescription * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SubpassDescription * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SubpassDependency * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassCreateInfo const & ) const = default;
#else
bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
- ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) &&
- ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderPassCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.attachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentDescription *, seed, renderPassCreateInfo.pAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.subpassCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassDescription *, seed, renderPassCreateInfo.pSubpasses );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.dependencyCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SubpassDependency *, seed, renderPassCreateInfo.pDependencies );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassDescription2
{
using NativeType = VkSubpassDescription2;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassDescription2 *>( this );
}
- operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassDescription2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags const &,
+ VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ pipelineBindPoint,
+ viewMask,
+ inputAttachmentCount,
+ pInputAttachments,
+ colorAttachmentCount,
+ pColorAttachments,
+ pResolveAttachments,
+ pDepthStencilAttachment,
+ preserveAttachmentCount,
+ pPreserveAttachments );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassDescription2 const & ) const = default;
#else
bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SubpassDescription2KHR = SubpassDescription2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescription2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescription2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription2.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription2.pipelineBindPoint );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.viewMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.inputAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pInputAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.colorAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pColorAttachments );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pResolveAttachments );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pDepthStencilAttachment );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.preserveAttachmentCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription2.pPreserveAttachments );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassDependency2
{
using NativeType = VkSubpassDependency2;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassDependency2 *>( this );
}
- operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassDependency2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::AccessFlags const &,
+ VULKAN_HPP_NAMESPACE::DependencyFlags const &,
+ int32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ srcSubpass,
+ dstSubpass,
+ srcStageMask,
+ dstStageMask,
+ srcAccessMask,
+ dstAccessMask,
+ dependencyFlags,
+ viewOffset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassDependency2 const & ) const = default;
#else
bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SubpassDependency2KHR = SubpassDependency2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDependency2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDependency2.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.srcSubpass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.dstSubpass );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.srcStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.dstStageMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.srcAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.dstAccessMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency2.dependencyFlags );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, subpassDependency2.viewOffset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassCreateInfo2
{
using NativeType = VkRenderPassCreateInfo2;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassCreateInfo2 *>( this );
}
- operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassCreateInfo2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RenderPassCreateFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentDescription2 * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SubpassDescription2 * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SubpassDependency2 * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ attachmentCount,
+ pAttachments,
+ subpassCount,
+ pSubpasses,
+ dependencyCount,
+ pDependencies,
+ correlatedViewMaskCount,
+ pCorrelatedViewMasks );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassCreateInfo2 const & ) const = default;
#else
bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo2.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo2.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo2.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.attachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::AttachmentDescription2 *, seed, renderPassCreateInfo2.pAttachments );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.subpassCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SubpassDescription2 *, seed, renderPassCreateInfo2.pSubpasses );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.dependencyCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SubpassDependency2 *, seed, renderPassCreateInfo2.pDependencies );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.correlatedViewMaskCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassCreateInfo2.pCorrelatedViewMasks );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassFragmentDensityMapCreateInfoEXT
{
using NativeType = VkRenderPassFragmentDensityMapCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>( this );
}
- operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::AttachmentReference const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentDensityMapAttachment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default;
#else
bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderPassFragmentDensityMapCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const &
- renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassFragmentDensityMapCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassFragmentDensityMapCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentReference,
- seed,
- renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassInputAttachmentAspectCreateInfo
{
using NativeType = VkRenderPassInputAttachmentAspectCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>( this );
}
- operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default;
#else
bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) &&
- ( pAspectReferences == rhs.pAspectReferences );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const &
- renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassInputAttachmentAspectCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassInputAttachmentAspectCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference *,
- seed,
- renderPassInputAttachmentAspectCreateInfo.pAspectReferences );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassMultiviewCreateInfo
{
using NativeType = VkRenderPassMultiviewCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>( this );
}
- operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassMultiviewCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ uint32_t const &,
+ const int32_t * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ subpassCount,
+ pViewMasks,
+ dependencyCount,
+ pViewOffsets,
+ correlationMaskCount,
+ pCorrelationMasks );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default;
#else
bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) &&
- ( pViewMasks == rhs.pViewMasks ) && ( dependencyCount == rhs.dependencyCount ) &&
- ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) &&
- ( pCorrelationMasks == rhs.pCorrelationMasks );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassMultiviewCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassMultiviewCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.subpassCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pViewMasks );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.dependencyCount );
- VULKAN_HPP_HASH_COMBINE( const int32_t *, seed, renderPassMultiviewCreateInfo.pViewOffsets );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.correlationMaskCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pCorrelationMasks );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassSampleLocationsEXT
{
using NativeType = VkSubpassSampleLocationsEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassSampleLocationsEXT *>( this );
}
- operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassSampleLocationsEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( subpassIndex, sampleLocationsInfo );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassSampleLocationsEXT const & ) const = default;
#else
bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>::value,
"SubpassSampleLocationsEXT is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassSampleLocationsEXT.subpassIndex );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, subpassSampleLocationsEXT.sampleLocationsInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassSampleLocationsBeginInfoEXT
{
using NativeType = VkRenderPassSampleLocationsBeginInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>( this );
}
- operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ attachmentInitialSampleLocationsCount,
+ pAttachmentInitialSampleLocations,
+ postSubpassSampleLocationsCount,
+ pPostSubpassSampleLocations );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default;
#else
bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) &&
- ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) &&
- ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) &&
- ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderPassSampleLocationsBeginInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const &
- renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassSampleLocationsBeginInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassSampleLocationsBeginInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT *,
- seed,
- renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT *,
- seed,
- renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderPassTransformBeginInfoQCOM
{
using NativeType = VkRenderPassTransformBeginInfoQCOM;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM *>( this );
}
- operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassTransformBeginInfoQCOM *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, transform );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default;
#else
bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderPassTransformBeginInfoQCOM;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassTransformBeginInfoQCOM.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, renderPassTransformBeginInfoQCOM.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, renderPassTransformBeginInfoQCOM.transform );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderingAttachmentInfoKHR
{
using NativeType = VkRenderingAttachmentInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderingAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderingAttachmentInfoKHR *>( this );
}
- operator VkRenderingAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderingAttachmentInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
+ VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
+ VULKAN_HPP_NAMESPACE::ClearValue const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ imageView,
+ imageLayout,
+ resolveMode,
+ resolveImageView,
+ resolveImageLayout,
+ loadOp,
+ storeOp,
+ clearValue );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderingAttachmentInfoKHR;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>( this );
}
- operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageView, imageLayout );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default;
#else
bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
- ( imageLayout == rhs.imageLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderingFragmentDensityMapAttachmentInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const &
- renderingFragmentDensityMapAttachmentInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentDensityMapAttachmentInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderingFragmentShadingRateAttachmentInfoKHR
{
using NativeType = VkRenderingFragmentShadingRateAttachmentInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>( this );
}
- operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default;
#else
bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
- ( imageLayout == rhs.imageLayout ) &&
- ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderingFragmentShadingRateAttachmentInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const &
- renderingFragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentShadingRateAttachmentInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D,
- seed,
- renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct RenderingInfoKHR
{
using NativeType = VkRenderingInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderingInfoKHR *>( this );
}
- operator VkRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderingInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::RenderingFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::Rect2D const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &,
+ const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &,
+ const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ renderArea,
+ layerCount,
+ viewMask,
+ colorAttachmentCount,
+ pColorAttachments,
+ pDepthAttachment,
+ pStencilAttachment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderingInfoKHR const & ) const = default;
#else
bool operator==( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( renderArea == rhs.renderArea ) && ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) &&
- ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
- ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = RenderingInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::RenderingInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfoKHR const & renderingInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderingInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, renderingInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderingInfoKHR.renderArea );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.layerCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.viewMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.colorAttachmentCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pColorAttachments );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pDepthAttachment );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pStencilAttachment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ResolveImageInfo2KHR
{
using NativeType = VkResolveImageInfo2KHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkResolveImageInfo2KHR *>( this );
}
- operator VkResolveImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkResolveImageInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkResolveImageInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ VULKAN_HPP_NAMESPACE::Image const &,
+ VULKAN_HPP_NAMESPACE::ImageLayout const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ImageResolve2KHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ResolveImageInfo2KHR const & ) const = default;
#else
bool operator==( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
- ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
- ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
- ( pRegions == rhs.pRegions );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ResolveImageInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR const & resolveImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, resolveImageInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, resolveImageInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.srcImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.srcImageLayout );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.dstImage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.dstImageLayout );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, resolveImageInfo2KHR.regionCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageResolve2KHR *, seed, resolveImageInfo2KHR.pRegions );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SamplerBorderColorComponentMappingCreateInfoEXT
{
using NativeType = VkSamplerBorderColorComponentMappingCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT *>( this );
}
- operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, components, srgb );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default;
#else
bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) &&
- ( srgb == rhs.srgb );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SamplerBorderColorComponentMappingCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const &
- samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, samplerBorderColorComponentMappingCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerBorderColorComponentMappingCreateInfoEXT.components );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SamplerCreateInfo
{
using NativeType = VkSamplerCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerCreateInfo *>( this );
}
- operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SamplerCreateFlags const &,
+ VULKAN_HPP_NAMESPACE::Filter const &,
+ VULKAN_HPP_NAMESPACE::Filter const &,
+ VULKAN_HPP_NAMESPACE::SamplerMipmapMode const &,
+ VULKAN_HPP_NAMESPACE::SamplerAddressMode const &,
+ VULKAN_HPP_NAMESPACE::SamplerAddressMode const &,
+ VULKAN_HPP_NAMESPACE::SamplerAddressMode const &,
+ float const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ float const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::CompareOp const &,
+ float const &,
+ float const &,
+ VULKAN_HPP_NAMESPACE::BorderColor const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ magFilter,
+ minFilter,
+ mipmapMode,
+ addressModeU,
+ addressModeV,
+ addressModeW,
+ mipLodBias,
+ anisotropyEnable,
+ maxAnisotropy,
+ compareEnable,
+ compareOp,
+ minLod,
+ maxLod,
+ borderColor,
+ unnormalizedCoordinates );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerCreateInfo const & ) const = default;
#else
bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SamplerCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerCreateFlags, seed, samplerCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.magFilter );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.minFilter );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerMipmapMode, seed, samplerCreateInfo.mipmapMode );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeU );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeV );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeW );
- VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.mipLodBias );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.anisotropyEnable );
- VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxAnisotropy );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.compareEnable );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, samplerCreateInfo.compareOp );
- VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.minLod );
- VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxLod );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BorderColor, seed, samplerCreateInfo.borderColor );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.unnormalizedCoordinates );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SamplerCustomBorderColorCreateInfoEXT
{
using NativeType = VkSamplerCustomBorderColorCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>( this );
}
- operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ClearColorValue const &,
+ VULKAN_HPP_NAMESPACE::Format const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, customBorderColor, format );
+ }
+
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerCustomBorderColorCreateInfoEXT;
const void * pNext = {};
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerReductionModeCreateInfo *>( this );
}
- operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerReductionModeCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SamplerReductionMode const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, reductionMode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default;
#else
bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerReductionModeCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerReductionModeCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerReductionMode, seed, samplerReductionModeCreateInfo.reductionMode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SamplerYcbcrConversionCreateInfo
{
using NativeType = VkSamplerYcbcrConversionCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( this );
}
- operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
+ VULKAN_HPP_NAMESPACE::ComponentMapping const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+ VULKAN_HPP_NAMESPACE::ChromaLocation const &,
+ VULKAN_HPP_NAMESPACE::Filter const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ format,
+ ycbcrModel,
+ ycbcrRange,
+ components,
+ xChromaOffset,
+ yChromaOffset,
+ chromaFilter,
+ forceExplicitReconstruction );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default;
#else
bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, samplerYcbcrConversionCreateInfo.format );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, samplerYcbcrConversionCreateInfo.ycbcrModel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, samplerYcbcrConversionCreateInfo.ycbcrRange );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerYcbcrConversionCreateInfo.components );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.xChromaOffset );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.yChromaOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerYcbcrConversionCreateInfo.chromaFilter );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SamplerYcbcrConversionImageFormatProperties
{
using NativeType = VkSamplerYcbcrConversionImageFormatProperties;
return *this;
}
- operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>( this );
}
- operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, combinedImageSamplerDescriptorCount );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default;
#else
bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const &
- samplerYcbcrConversionImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionImageFormatProperties.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, samplerYcbcrConversionImageFormatProperties.pNext );
- VULKAN_HPP_HASH_COMBINE(
- uint32_t, seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SamplerYcbcrConversionInfo
{
using NativeType = VkSamplerYcbcrConversionInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSamplerYcbcrConversionInfo *>( this );
}
- operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSamplerYcbcrConversionInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, conversion );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default;
#else
bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionInfo.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, seed, samplerYcbcrConversionInfo.conversion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
struct ScreenSurfaceCreateInfoQNX
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( this );
}
- operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkScreenSurfaceCreateInfoQNX *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX const &,
+ struct _screen_context * const &,
+ struct _screen_window * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, context, window );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default;
# else
bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) &&
- ( window == rhs.window );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ScreenSurfaceCreateInfoQNX;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, screenSurfaceCreateInfoQNX.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, screenSurfaceCreateInfoQNX.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX, seed, screenSurfaceCreateInfoQNX.flags );
- VULKAN_HPP_HASH_COMBINE( struct _screen_context *, seed, screenSurfaceCreateInfoQNX.context );
- VULKAN_HPP_HASH_COMBINE( struct _screen_window *, seed, screenSurfaceCreateInfoQNX.window );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
struct SemaphoreCreateInfo
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreCreateInfo *>( this );
}
- operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreCreateInfo const & ) const = default;
#else
bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SemaphoreCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags, seed, semaphoreCreateInfo.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SemaphoreGetFdInfoKHR
{
using NativeType = VkSemaphoreGetFdInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( this );
}
- operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreGetFdInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, handleType );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default;
#else
bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SemaphoreGetFdInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetFdInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetFdInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetFdInfoKHR.semaphore );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetFdInfoKHR.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct SemaphoreGetWin32HandleInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( this );
}
- operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, handleType );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default;
# else
bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = SemaphoreGetWin32HandleInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetWin32HandleInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetWin32HandleInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetWin32HandleInfoKHR.semaphore );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetWin32HandleInfoKHR.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( this );
}
- operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, handleType );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default;
# else
bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( handleType == rhs.handleType );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = SemaphoreGetZirconHandleInfoFUCHSIA;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const &
- semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetZirconHandleInfoFUCHSIA.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_FUCHSIA*/
struct SemaphoreSignalInfo
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreSignalInfo *>( this );
}
- operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreSignalInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, value );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreSignalInfo const & ) const = default;
#else
bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( value == rhs.value );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSignalInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSignalInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSignalInfo.semaphore );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSignalInfo.value );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SemaphoreSubmitInfoKHR
{
using NativeType = VkSemaphoreSubmitInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreSubmitInfoKHR *>( this );
}
- operator VkSemaphoreSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreSubmitInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Semaphore const &,
+ uint64_t const &,
+ VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreSubmitInfoKHR const & ) const = default;
#else
bool operator==( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
- ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && ( deviceIndex == rhs.deviceIndex );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SemaphoreSubmitInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR const & semaphoreSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSubmitInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSubmitInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSubmitInfoKHR.semaphore );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSubmitInfoKHR.value );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, semaphoreSubmitInfoKHR.stageMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreSubmitInfoKHR.deviceIndex );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SemaphoreTypeCreateInfo
{
using NativeType = VkSemaphoreTypeCreateInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreTypeCreateInfo *>( this );
}
- operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreTypeCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SemaphoreType const &,
+ uint64_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, semaphoreType, initialValue );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default;
#else
bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) &&
- ( initialValue == rhs.initialValue );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreTypeCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreTypeCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreType, seed, semaphoreTypeCreateInfo.semaphoreType );
- VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreTypeCreateInfo.initialValue );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SemaphoreWaitInfo
{
using NativeType = VkSemaphoreWaitInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSemaphoreWaitInfo *>( this );
}
- operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSemaphoreWaitInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+ const uint64_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SemaphoreWaitInfo const & ) const = default;
#else
bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( semaphoreCount == rhs.semaphoreCount ) && ( pSemaphores == rhs.pSemaphores ) &&
- ( pValues == rhs.pValues );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreWaitInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreWaitInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags, seed, semaphoreWaitInfo.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreWaitInfo.semaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, semaphoreWaitInfo.pSemaphores );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, semaphoreWaitInfo.pValues );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SetStateFlagsIndirectCommandNV
{
using NativeType = VkSetStateFlagsIndirectCommandNV;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSetStateFlagsIndirectCommandNV *>( this );
}
- operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSetStateFlagsIndirectCommandNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( data );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default;
#else
bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( data == rhs.data );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>::value,
"SetStateFlagsIndirectCommandNV is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, setStateFlagsIndirectCommandNV.data );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ShaderModuleCreateInfo
{
using NativeType = VkShaderModuleCreateInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkShaderModuleCreateInfo *>( this );
}
- operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkShaderModuleCreateInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags const &,
+ size_t const &,
+ const uint32_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, codeSize, pCode );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ShaderModuleCreateInfo const & ) const = default;
#else
bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ShaderModuleCreateInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleCreateInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleCreateInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags, seed, shaderModuleCreateInfo.flags );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderModuleCreateInfo.codeSize );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, shaderModuleCreateInfo.pCode );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ShaderModuleValidationCacheCreateInfoEXT
{
using NativeType = VkShaderModuleValidationCacheCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>( this );
}
- operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ValidationCacheEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, validationCache );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default;
#else
bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ShaderModuleValidationCacheCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const &
- shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleValidationCacheCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleValidationCacheCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ValidationCacheEXT, seed, shaderModuleValidationCacheCreateInfoEXT.validationCache );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ShaderResourceUsageAMD
{
using NativeType = VkShaderResourceUsageAMD;
return *this;
}
- operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkShaderResourceUsageAMD *>( this );
}
- operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkShaderResourceUsageAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, size_t const &, size_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ShaderResourceUsageAMD const & ) const = default;
#else
bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) &&
- ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) &&
- ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) &&
- ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>::value,
"ShaderResourceUsageAMD is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedVgprs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedSgprs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.ldsUsageSizeInBytes );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.scratchMemUsageInBytes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ShaderStatisticsInfoAMD
{
using NativeType = VkShaderStatisticsInfoAMD;
return *this;
}
- operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkShaderStatisticsInfoAMD *>( this );
}
- operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkShaderStatisticsInfoAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
+ VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( shaderStageMask,
+ resourceUsage,
+ numPhysicalVgprs,
+ numPhysicalSgprs,
+ numAvailableVgprs,
+ numAvailableSgprs,
+ computeWorkGroupSize );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default;
#else
bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) &&
- ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) &&
- ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) &&
- ( computeWorkGroupSize == rhs.computeWorkGroupSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>::value,
"ShaderStatisticsInfoAMD is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, shaderStatisticsInfoAMD.shaderStageMask );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD, seed, shaderStatisticsInfoAMD.resourceUsage );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalVgprs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalSgprs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableVgprs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableSgprs );
- for ( size_t i = 0; i < 3; ++i )
- {
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] );
- }
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SharedPresentSurfaceCapabilitiesKHR
{
using NativeType = VkSharedPresentSurfaceCapabilitiesKHR;
return *this;
}
- operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>( this );
}
- operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, sharedPresentSupportedUsageFlags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default;
#else
bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SharedPresentSurfaceCapabilitiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const &
- sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sharedPresentSurfaceCapabilitiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, sharedPresentSurfaceCapabilitiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags,
- seed,
- sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageFormatProperties
{
using NativeType = VkSparseImageFormatProperties;
return *this;
}
- operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageFormatProperties *>( this );
}
- operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageFormatProperties *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &,
+ VULKAN_HPP_NAMESPACE::Extent3D const &,
+ VULKAN_HPP_NAMESPACE::SparseImageFormatFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( aspectMask, imageGranularity, flags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageFormatProperties const & ) const = default;
#else
bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
"SparseImageFormatProperties is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, sparseImageFormatProperties.aspectMask );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageFormatProperties.imageGranularity );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseImageFormatFlags, seed, sparseImageFormatProperties.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageFormatProperties2
{
using NativeType = VkSparseImageFormatProperties2;
return *this;
}
- operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageFormatProperties2 *>( this );
}
- operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageFormatProperties2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, properties );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageFormatProperties2 const & ) const = default;
#else
bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageFormatProperties2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageFormatProperties2.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageFormatProperties2.properties );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageMemoryRequirements
{
using NativeType = VkSparseImageMemoryRequirements;
return *this;
}
- operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageMemoryRequirements *>( this );
}
- operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageMemoryRequirements *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageMemoryRequirements const & ) const = default;
#else
bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) &&
- ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) &&
- ( imageMipTailStride == rhs.imageMipTailStride );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
"SparseImageMemoryRequirements is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageMemoryRequirements.formatProperties );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryRequirements.imageMipTailFirstLod );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailSize );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailStride );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SparseImageMemoryRequirements2
{
using NativeType = VkSparseImageMemoryRequirements2;
return *this;
}
- operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSparseImageMemoryRequirements2 *>( this );
}
- operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSparseImageMemoryRequirements2 *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryRequirements );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default;
#else
bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageMemoryRequirements2.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageMemoryRequirements2.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, seed, sparseImageMemoryRequirements2.memoryRequirements );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_GGP )
struct StreamDescriptorSurfaceCreateInfoGGP
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( this );
}
- operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP const &,
+ GgpStreamDescriptor const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, streamDescriptor );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & ) const = default;
# else
bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = StreamDescriptorSurfaceCreateInfoGGP;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &
- streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, streamDescriptorSurfaceCreateInfoGGP.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, streamDescriptorSurfaceCreateInfoGGP.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP, seed, streamDescriptorSurfaceCreateInfoGGP.flags );
- VULKAN_HPP_HASH_COMBINE( GgpStreamDescriptor, seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_GGP*/
struct StridedDeviceAddressRegionKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( this );
}
- operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkStridedDeviceAddressRegionKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( deviceAddress, stride, size );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default;
#else
bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>::value,
"StridedDeviceAddressRegionKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, stridedDeviceAddressRegionKHR.deviceAddress );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.stride );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.size );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubmitInfo
{
using NativeType = VkSubmitInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubmitInfo *>( this );
}
- operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubmitInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Semaphore * const &,
+ const VULKAN_HPP_NAMESPACE::PipelineStageFlags * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::CommandBuffer * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Semaphore * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ waitSemaphoreCount,
+ pWaitSemaphores,
+ pWaitDstStageMask,
+ commandBufferCount,
+ pCommandBuffers,
+ signalSemaphoreCount,
+ pSignalSemaphores );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubmitInfo const & ) const = default;
#else
bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
- ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) &&
- ( commandBufferCount == rhs.commandBufferCount ) && ( pCommandBuffers == rhs.pCommandBuffers ) &&
- ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && ( pSignalSemaphores == rhs.pSignalSemaphores );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SubmitInfo;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.waitSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pWaitSemaphores );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineStageFlags *, seed, submitInfo.pWaitDstStageMask );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.commandBufferCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CommandBuffer *, seed, submitInfo.pCommandBuffers );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.signalSemaphoreCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pSignalSemaphores );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubmitInfo2KHR
{
using NativeType = VkSubmitInfo2KHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubmitInfo2KHR *>( this );
}
- operator VkSubmitInfo2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubmitInfo2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubmitInfo2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SubmitFlagsKHR const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ waitSemaphoreInfoCount,
+ pWaitSemaphoreInfos,
+ commandBufferInfoCount,
+ pCommandBufferInfos,
+ signalSemaphoreInfoCount,
+ pSignalSemaphoreInfos );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubmitInfo2KHR const & ) const = default;
#else
bool operator==( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) &&
- ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) &&
- ( commandBufferInfoCount == rhs.commandBufferInfoCount ) &&
- ( pCommandBufferInfos == rhs.pCommandBufferInfos ) &&
- ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) &&
- ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SubmitInfo2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubmitInfo2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2KHR const & submitInfo2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubmitFlagsKHR, seed, submitInfo2KHR.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.waitSemaphoreInfoCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pWaitSemaphoreInfos );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.commandBufferInfoCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR *, seed, submitInfo2KHR.pCommandBufferInfos );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.signalSemaphoreInfoCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pSignalSemaphoreInfos );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassBeginInfo
{
using NativeType = VkSubpassBeginInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassBeginInfo *>( this );
}
- operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassBeginInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SubpassContents const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, contents );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassBeginInfo const & ) const = default;
#else
bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SubpassBeginInfoKHR = SubpassBeginInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassBeginInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassBeginInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassContents, seed, subpassBeginInfo.contents );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassDescriptionDepthStencilResolve
{
using NativeType = VkSubpassDescriptionDepthStencilResolve;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve *>( this );
}
- operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassDescriptionDepthStencilResolve *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
+ VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
+ const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default;
#else
bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) &&
- ( stencilResolveMode == rhs.stencilResolveMode ) &&
- ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const &
- subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescriptionDepthStencilResolve.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescriptionDepthStencilResolve.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.depthResolveMode );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.stencilResolveMode );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *,
- seed,
- subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassEndInfo
{
using NativeType = VkSubpassEndInfo;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassEndInfo *>( this );
}
- operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassEndInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassEndInfo const & ) const = default;
#else
bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using SubpassEndInfoKHR = SubpassEndInfo;
-} // namespace VULKAN_HPP_NAMESPACE
+ struct SubpassFragmentDensityMapOffsetEndInfoQCOM
+ {
+ using NativeType = VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+ StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM(
+ uint32_t fragmentDensityOffsetCount_ = {},
+ const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ = {} ) VULKAN_HPP_NOEXCEPT
+ : fragmentDensityOffsetCount( fragmentDensityOffsetCount_ )
+ , pFragmentDensityOffsets( pFragmentDensityOffsets_ )
+ {}
+
+ VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM(
+ SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ SubpassFragmentDensityMapOffsetEndInfoQCOM( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs )
+ VULKAN_HPP_NOEXCEPT
+ : SubpassFragmentDensityMapOffsetEndInfoQCOM(
+ *reinterpret_cast<SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs ) )
+ {}
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ SubpassFragmentDensityMapOffsetEndInfoQCOM(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const &
+ fragmentDensityOffsets_ )
+ : fragmentDensityOffsetCount( static_cast<uint32_t>( fragmentDensityOffsets_.size() ) )
+ , pFragmentDensityOffsets( fragmentDensityOffsets_.data() )
+ {}
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ SubpassFragmentDensityMapOffsetEndInfoQCOM &
+ operator=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ SubpassFragmentDensityMapOffsetEndInfoQCOM &
+ operator=( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
+ setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
+ setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ fragmentDensityOffsetCount = fragmentDensityOffsetCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
+ setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pFragmentDensityOffsets = pFragmentDensityOffsets_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ SubpassFragmentDensityMapOffsetEndInfoQCOM & setFragmentDensityOffsets(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const &
+ fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
+ {
+ fragmentDensityOffsetCount = static_cast<uint32_t>( fragmentDensityOffsets_.size() );
+ pFragmentDensityOffsets = fragmentDensityOffsets_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ explicit operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
+ }
+
+ explicit operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
+ }
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::Offset2D * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
+ }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default;
+#else
+ bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() == rhs.reflect();
+ }
+
+ bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return this->reflect() != rhs.reflect();
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
+ const void * pNext = {};
+ uint32_t fragmentDensityOffsetCount = {};
+ const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets = {};
+ };
+ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) ==
+ sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
+ "struct and wrapper have different size!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
+ "struct wrapper is not a standard layout!" );
+ VULKAN_HPP_STATIC_ASSERT(
+ std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
+ "SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
+
+ template <>
+ struct CppType<StructureType, StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM>
{
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassEndInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassEndInfo.pNext );
- return seed;
- }
-};
+ using Type = SubpassFragmentDensityMapOffsetEndInfoQCOM;
+ };
-namespace VULKAN_HPP_NAMESPACE
-{
struct SubpassShadingPipelineCreateInfoHUAWEI
{
using NativeType = VkSubpassShadingPipelineCreateInfoHUAWEI;
return *this;
}
- operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI *>( this );
}
- operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::RenderPass const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, renderPass, subpass );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default;
#else
bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
- ( subpass == rhs.subpass );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SubpassShadingPipelineCreateInfoHUAWEI;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const &
- subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassShadingPipelineCreateInfoHUAWEI.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, subpassShadingPipelineCreateInfoHUAWEI.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::RenderPass, seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassShadingPipelineCreateInfoHUAWEI.subpass );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SurfaceCapabilities2EXT
{
using NativeType = VkSurfaceCapabilities2EXT;
return *this;
}
- operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceCapabilities2EXT *>( this );
}
- operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceCapabilities2EXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ minImageCount,
+ maxImageCount,
+ currentExtent,
+ minImageExtent,
+ maxImageExtent,
+ maxImageArrayLayers,
+ supportedTransforms,
+ currentTransform,
+ supportedCompositeAlpha,
+ supportedUsageFlags,
+ supportedSurfaceCounters );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceCapabilities2EXT const & ) const = default;
#else
bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) &&
- ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) &&
- ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) &&
- ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) &&
- ( currentTransform == rhs.currentTransform ) &&
- ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) &&
- ( supportedUsageFlags == rhs.supportedUsageFlags ) &&
- ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SurfaceCapabilities2EXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2EXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2EXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.minImageCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.currentExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.minImageExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.maxImageExtent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageArrayLayers );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilities2EXT.supportedTransforms );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilities2EXT.currentTransform );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilities2EXT.supportedCompositeAlpha );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilities2EXT.supportedUsageFlags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, surfaceCapabilities2EXT.supportedSurfaceCounters );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SurfaceCapabilitiesKHR
{
using NativeType = VkSurfaceCapabilitiesKHR;
return *this;
}
- operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceCapabilitiesKHR *>( this );
}
- operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceCapabilitiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( minImageCount,
+ maxImageCount,
+ currentExtent,
+ minImageExtent,
+ maxImageExtent,
+ maxImageArrayLayers,
+ supportedTransforms,
+ currentTransform,
+ supportedCompositeAlpha,
+ supportedUsageFlags );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default;
#else
bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) &&
- ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) &&
- ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) &&
- ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) &&
- ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) &&
- ( supportedUsageFlags == rhs.supportedUsageFlags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::value,
"SurfaceCapabilitiesKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.minImageCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.currentExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.minImageExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.maxImageExtent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageArrayLayers );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilitiesKHR.supportedTransforms );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilitiesKHR.currentTransform );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilitiesKHR.supportedCompositeAlpha );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilitiesKHR.supportedUsageFlags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SurfaceCapabilities2KHR
{
using NativeType = VkSurfaceCapabilities2KHR;
return *this;
}
- operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceCapabilities2KHR *>( this );
}
- operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceCapabilities2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, surfaceCapabilities );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceCapabilities2KHR const & ) const = default;
#else
bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SurfaceCapabilities2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR, seed, surfaceCapabilities2KHR.surfaceCapabilities );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct SurfaceCapabilitiesFullScreenExclusiveEXT
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>( this );
}
- operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fullScreenExclusiveSupported );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default;
# else
bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = SurfaceCapabilitiesFullScreenExclusiveEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const &
- surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct SurfaceFormatKHR
return *this;
}
- operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceFormatKHR *>( this );
}
- operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceFormatKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::Format const &, VULKAN_HPP_NAMESPACE::ColorSpaceKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( format, colorSpace );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceFormatKHR const & ) const = default;
#else
bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value,
"SurfaceFormatKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, surfaceFormatKHR.format );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, surfaceFormatKHR.colorSpace );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SurfaceFormat2KHR
{
using NativeType = VkSurfaceFormat2KHR;
return *this;
}
- operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceFormat2KHR *>( this );
}
- operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceFormat2KHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, surfaceFormat );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceFormat2KHR const & ) const = default;
#else
bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SurfaceFormat2KHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFormat2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFormat2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, seed, surfaceFormat2KHR.surfaceFormat );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct SurfaceFullScreenExclusiveInfoEXT
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>( this );
}
- operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, fullScreenExclusive );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default;
# else
bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = SurfaceFullScreenExclusiveInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const &
- surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFullScreenExclusiveInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT, seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>( this );
}
- operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, HMONITOR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, hmonitor );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default;
# else
bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = SurfaceFullScreenExclusiveWin32InfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const &
- surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveWin32InfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( HMONITOR, seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct SurfaceProtectedCapabilitiesKHR
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>( this );
}
- operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, supportsProtected );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default;
#else
bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SurfaceProtectedCapabilitiesKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceProtectedCapabilitiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceProtectedCapabilitiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceProtectedCapabilitiesKHR.supportsProtected );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SwapchainCounterCreateInfoEXT
{
using NativeType = VkSwapchainCounterCreateInfoEXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>( this );
}
- operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, surfaceCounters );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default;
#else
bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SwapchainCounterCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCounterCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCounterCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, swapchainCounterCreateInfoEXT.surfaceCounters );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SwapchainCreateInfoKHR
{
using NativeType = VkSwapchainCreateInfoKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSwapchainCreateInfoKHR *>( this );
}
- operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSwapchainCreateInfoKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::SurfaceKHR const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::ColorSpaceKHR const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
+ VULKAN_HPP_NAMESPACE::SharingMode const &,
+ uint32_t const &,
+ const uint32_t * const &,
+ VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::PresentModeKHR const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::SwapchainKHR const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ surface,
+ minImageCount,
+ imageFormat,
+ imageColorSpace,
+ imageExtent,
+ imageArrayLayers,
+ imageUsage,
+ imageSharingMode,
+ queueFamilyIndexCount,
+ pQueueFamilyIndices,
+ preTransform,
+ compositeAlpha,
+ presentMode,
+ clipped,
+ oldSwapchain );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SwapchainCreateInfoKHR const & ) const = default;
#else
bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) &&
- ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) &&
- ( imageColorSpace == rhs.imageColorSpace ) && ( imageExtent == rhs.imageExtent ) &&
- ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) &&
- ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
- ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) &&
- ( compositeAlpha == rhs.compositeAlpha ) && ( presentMode == rhs.presentMode ) &&
- ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SwapchainCreateInfoKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR, seed, swapchainCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, swapchainCreateInfoKHR.surface );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.minImageCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, swapchainCreateInfoKHR.imageFormat );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, swapchainCreateInfoKHR.imageColorSpace );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, swapchainCreateInfoKHR.imageExtent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.imageArrayLayers );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, swapchainCreateInfoKHR.imageUsage );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, swapchainCreateInfoKHR.imageSharingMode );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.queueFamilyIndexCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, swapchainCreateInfoKHR.pQueueFamilyIndices );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, swapchainCreateInfoKHR.preTransform );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR, seed, swapchainCreateInfoKHR.compositeAlpha );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PresentModeKHR, seed, swapchainCreateInfoKHR.presentMode );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainCreateInfoKHR.clipped );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, swapchainCreateInfoKHR.oldSwapchain );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct SwapchainDisplayNativeHdrCreateInfoAMD
{
using NativeType = VkSwapchainDisplayNativeHdrCreateInfoAMD;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>( this );
}
- operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, localDimmingEnable );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default;
#else
bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = SwapchainDisplayNativeHdrCreateInfoAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const &
- swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainDisplayNativeHdrCreateInfoAMD.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct TextureLODGatherFormatPropertiesAMD
{
using NativeType = VkTextureLODGatherFormatPropertiesAMD;
return *this;
}
- operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>( this );
}
- operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default;
#else
bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = TextureLODGatherFormatPropertiesAMD;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const &
- textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, textureLODGatherFormatPropertiesAMD.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, textureLODGatherFormatPropertiesAMD.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct TimelineSemaphoreSubmitInfo
{
using NativeType = VkTimelineSemaphoreSubmitInfo;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTimelineSemaphoreSubmitInfo *>( this );
}
- operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTimelineSemaphoreSubmitInfo *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const uint64_t * const &,
+ uint32_t const &,
+ const uint64_t * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ waitSemaphoreValueCount,
+ pWaitSemaphoreValues,
+ signalSemaphoreValueCount,
+ pSignalSemaphoreValues );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default;
#else
bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) &&
- ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) &&
- ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) &&
- ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
};
using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, timelineSemaphoreSubmitInfo.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, timelineSemaphoreSubmitInfo.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct TraceRaysIndirectCommandKHR
{
using NativeType = VkTraceRaysIndirectCommandKHR;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTraceRaysIndirectCommandKHR *>( this );
}
- operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTraceRaysIndirectCommandKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( width, height, depth );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default;
#else
bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>::value,
"TraceRaysIndirectCommandKHR is not nothrow_move_constructible!" );
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.width );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.height );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.depth );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ValidationCacheCreateInfoEXT
{
using NativeType = VkValidationCacheCreateInfoEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( this );
}
- operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkValidationCacheCreateInfoEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT const &,
+ size_t const &,
+ const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default;
#else
bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ValidationCacheCreateInfoEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
-{
- std::size_t operator()(
- VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationCacheCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT, seed, validationCacheCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( size_t, seed, validationCacheCreateInfoEXT.initialDataSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pInitialData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ValidationFeaturesEXT
{
using NativeType = VkValidationFeaturesEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkValidationFeaturesEXT *>( this );
}
- operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkValidationFeaturesEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ enabledValidationFeatureCount,
+ pEnabledValidationFeatures,
+ disabledValidationFeatureCount,
+ pDisabledValidationFeatures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ValidationFeaturesEXT const & ) const = default;
#else
bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) &&
- ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) &&
- ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) &&
- ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ValidationFeaturesEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFeaturesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFeaturesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.enabledValidationFeatureCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT *,
- seed,
- validationFeaturesEXT.pEnabledValidationFeatures );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.disabledValidationFeatureCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT *,
- seed,
- validationFeaturesEXT.pDisabledValidationFeatures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct ValidationFlagsEXT
{
using NativeType = VkValidationFlagsEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkValidationFlagsEXT *>( this );
}
- operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkValidationFlagsEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::ValidationCheckEXT * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ValidationFlagsEXT const & ) const = default;
#else
bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) &&
- ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = ValidationFlagsEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFlagsEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFlagsEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFlagsEXT.disabledValidationCheckCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::ValidationCheckEXT *, seed, validationFlagsEXT.pDisabledValidationChecks );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct VertexInputAttributeDescription2EXT
{
using NativeType = VkVertexInputAttributeDescription2EXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( this );
}
- operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVertexInputAttributeDescription2EXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, location, binding, format, offset );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default;
#else
bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) &&
- ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = VertexInputAttributeDescription2EXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const &
- vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputAttributeDescription2EXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputAttributeDescription2EXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.location );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.binding );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription2EXT.format );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.offset );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct VertexInputBindingDescription2EXT
{
using NativeType = VkVertexInputBindingDescription2EXT;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( this );
}
- operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVertexInputBindingDescription2EXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::VertexInputRate const &,
+ uint32_t const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, binding, stride, inputRate, divisor );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default;
#else
bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) &&
- ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && ( divisor == rhs.divisor );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = VertexInputBindingDescription2EXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const &
- vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputBindingDescription2EXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputBindingDescription2EXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.binding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.stride );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription2EXT.inputRate );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.divisor );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_VI_NN )
struct ViSurfaceCreateInfoNN
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkViSurfaceCreateInfoNN *>( this );
}
- operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkViSurfaceCreateInfoNN *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN const &,
+ void * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, window );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default;
# else
bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = ViSurfaceCreateInfoNN;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, viSurfaceCreateInfoNN.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, viSurfaceCreateInfoNN.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN, seed, viSurfaceCreateInfoNN.flags );
- VULKAN_HPP_HASH_COMBINE( void *, seed, viSurfaceCreateInfoNN.window );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_VI_NN*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoPictureResourceKHR *>( this );
}
- operator VkVideoPictureResourceKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoPictureResourceKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoPictureResourceKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ImageView const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoPictureResourceKHR const & ) const = default;
# else
bool operator==( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) &&
- ( codedExtent == rhs.codedExtent ) && ( baseArrayLayer == rhs.baseArrayLayer ) &&
- ( imageViewBinding == rhs.imageViewBinding );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoPictureResourceKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const & videoPictureResourceKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoPictureResourceKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoPictureResourceKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoPictureResourceKHR.codedOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoPictureResourceKHR.codedExtent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoPictureResourceKHR.baseArrayLayer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, videoPictureResourceKHR.imageViewBinding );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoReferenceSlotKHR *>( this );
}
- operator VkVideoReferenceSlotKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoReferenceSlotKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoReferenceSlotKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ int8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, slotIndex, pPictureResource );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoReferenceSlotKHR const & ) const = default;
# else
bool operator==( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
- ( pPictureResource == rhs.pPictureResource );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoReferenceSlotKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR const & videoReferenceSlotKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoReferenceSlotKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoReferenceSlotKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoReferenceSlotKHR.slotIndex );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR *, seed, videoReferenceSlotKHR.pPictureResource );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( this );
}
- operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoBeginCodingInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoCodingQualityPresetFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoSessionKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ codecQualityPreset,
+ videoSession,
+ videoSessionParameters,
+ referenceSlotCount,
+ pReferenceSlots );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default;
# else
bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( codecQualityPreset == rhs.codecQualityPreset ) && ( videoSession == rhs.videoSession ) &&
- ( videoSessionParameters == rhs.videoSessionParameters ) &&
- ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoBeginCodingInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBeginCodingInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBeginCodingInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR, seed, videoBeginCodingInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoCodingQualityPresetFlagsKHR, seed, videoBeginCodingInfoKHR.codecQualityPreset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoBeginCodingInfoKHR.videoSession );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, seed, videoBeginCodingInfoKHR.videoSessionParameters );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBeginCodingInfoKHR.referenceSlotCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoBeginCodingInfoKHR.pReferenceSlots );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoBindMemoryKHR *>( this );
}
- operator VkVideoBindMemoryKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoBindMemoryKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoBindMemoryKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DeviceMemory const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoBindMemoryKHR const & ) const = default;
# else
bool operator==( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) &&
- ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoBindMemoryKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR const & videoBindMemoryKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBindMemoryKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBindMemoryKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBindMemoryKHR.memoryBindIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, videoBindMemoryKHR.memory );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memoryOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memorySize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
return *this;
}
- operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoCapabilitiesKHR *>( this );
}
- operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoCapabilitiesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ capabilityFlags,
+ minBitstreamBufferOffsetAlignment,
+ minBitstreamBufferSizeAlignment,
+ videoPictureExtentGranularity,
+ minExtent,
+ maxExtent,
+ maxReferencePicturesSlotsCount,
+ maxReferencePicturesActiveCount );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoCapabilitiesKHR const & ) const = default;
# else
bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilityFlags == rhs.capabilityFlags ) &&
- ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) &&
- ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) &&
- ( videoPictureExtentGranularity == rhs.videoPictureExtentGranularity ) && ( minExtent == rhs.minExtent ) &&
- ( maxExtent == rhs.maxExtent ) &&
- ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) &&
- ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoCapabilitiesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCapabilitiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoCapabilitiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR, seed, videoCapabilitiesKHR.capabilityFlags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.videoPictureExtentGranularity );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.minExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.maxExtent );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesSlotsCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesActiveCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoCodingControlInfoKHR *>( this );
}
- operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoCodingControlInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoCodingControlInfoKHR const & ) const = default;
# else
bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoCodingControlInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCodingControlInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoCodingControlInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR, seed, videoCodingControlInfoKHR.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
return *this;
}
- operator VkVideoDecodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT *>( this );
}
- operator VkVideoDecodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxLevel, fieldOffsetGranularity, stdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) &&
- ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ) &&
- ( stdExtensionVersion == rhs.stdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264CapabilitiesEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT const & videoDecodeH264CapabilitiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264CapabilitiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH264CapabilitiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264CapabilitiesEXT.maxLevel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeH264CapabilitiesEXT.fieldOffsetGranularity );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH264CapabilitiesEXT.stdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT *>( this );
}
- operator VkVideoDecodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const StdVideoDecodeH264ReferenceInfo * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pStdReferenceInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264DpbSlotInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264DpbSlotInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT const & videoDecodeH264DpbSlotInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264DpbSlotInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264DpbSlotInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoDecodeH264ReferenceInfo *, seed, videoDecodeH264DpbSlotInfoEXT.pStdReferenceInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264MvcEXT *>( this );
}
- operator VkVideoDecodeH264MvcEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264MvcEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264MvcEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const StdVideoDecodeH264Mvc * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pStdMvc );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264MvcEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdMvc == rhs.pStdMvc );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264MvcEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT const & videoDecodeH264MvcEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264MvcEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264MvcEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( const StdVideoDecodeH264Mvc *, seed, videoDecodeH264MvcEXT.pStdMvc );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT *>( this );
}
- operator VkVideoDecodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264PictureInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const StdVideoDecodeH264PictureInfo * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264PictureInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) &&
- ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264PictureInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT const & videoDecodeH264PictureInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264PictureInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264PictureInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoDecodeH264PictureInfo *, seed, videoDecodeH264PictureInfoEXT.pStdPictureInfo );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264PictureInfoEXT.slicesCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH264PictureInfoEXT.pSlicesDataOffsets );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264ProfileEXT *>( this );
}
- operator VkVideoDecodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264ProfileEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ StdVideoH264ProfileIdc const &,
+ VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stdProfileIdc, pictureLayout );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264ProfileEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
- ( pictureLayout == rhs.pictureLayout );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264ProfileEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT const & videoDecodeH264ProfileEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264ProfileEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264ProfileEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoDecodeH264ProfileEXT.stdProfileIdc );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT, seed, videoDecodeH264ProfileEXT.pictureLayout );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT *>( this );
}
- operator VkVideoDecodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT const &,
+ const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pStdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264SessionCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264SessionCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT const &
- videoDecodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT, seed, videoDecodeH264SessionCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
- seed,
- videoDecodeH264SessionCreateInfoEXT.pStdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT *>( this );
}
- operator VkVideoDecodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const StdVideoH264SequenceParameterSet * const &,
+ uint32_t const &,
+ const StdVideoH264PictureParameterSet * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264SessionParametersAddInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
- ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264SessionParametersAddInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT const &
- videoDecodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersAddInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersAddInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.spsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH264SequenceParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pSpsStd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.ppsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH264PictureParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pPpsStd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT *>( this );
}
- operator VkVideoDecodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264SessionParametersCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
- ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH264SessionParametersCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT const &
- videoDecodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxSpsStdCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxPpsStdCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT *,
- seed,
- videoDecodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
return *this;
}
- operator VkVideoDecodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT *>( this );
}
- operator VkVideoDecodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxLevel, stdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) &&
- ( stdExtensionVersion == rhs.stdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265CapabilitiesEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT const & videoDecodeH265CapabilitiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265CapabilitiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH265CapabilitiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265CapabilitiesEXT.maxLevel );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH265CapabilitiesEXT.stdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT *>( this );
}
- operator VkVideoDecodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const StdVideoDecodeH265ReferenceInfo * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pStdReferenceInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265DpbSlotInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265DpbSlotInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT const & videoDecodeH265DpbSlotInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265DpbSlotInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265DpbSlotInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoDecodeH265ReferenceInfo *, seed, videoDecodeH265DpbSlotInfoEXT.pStdReferenceInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT *>( this );
}
- operator VkVideoDecodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265PictureInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ StdVideoDecodeH265PictureInfo * const &,
+ uint32_t const &,
+ const uint32_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265PictureInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) &&
- ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265PictureInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT const & videoDecodeH265PictureInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265PictureInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265PictureInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( StdVideoDecodeH265PictureInfo *, seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265PictureInfoEXT.slicesCount );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH265PictureInfoEXT.pSlicesDataOffsets );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265ProfileEXT *>( this );
}
- operator VkVideoDecodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265ProfileEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stdProfileIdc );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265ProfileEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265ProfileEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT const & videoDecodeH265ProfileEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265ProfileEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265ProfileEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoDecodeH265ProfileEXT.stdProfileIdc );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT *>( this );
}
- operator VkVideoDecodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT const &,
+ const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pStdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265SessionCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265SessionCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT const &
- videoDecodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT, seed, videoDecodeH265SessionCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
- seed,
- videoDecodeH265SessionCreateInfoEXT.pStdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT *>( this );
}
- operator VkVideoDecodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const StdVideoH265SequenceParameterSet * const &,
+ uint32_t const &,
+ const StdVideoH265PictureParameterSet * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265SessionParametersAddInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
- ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265SessionParametersAddInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT const &
- videoDecodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersAddInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersAddInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.spsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH265SequenceParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pSpsStd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.ppsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH265PictureParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pPpsStd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT *>( this );
}
- operator VkVideoDecodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265SessionParametersCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
- ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeH265SessionParametersCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT const &
- videoDecodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxSpsStdCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxPpsStdCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT *,
- seed,
- videoDecodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeInfoKHR *>( this );
}
- operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::Offset2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ codedOffset,
+ codedExtent,
+ srcBuffer,
+ srcBufferOffset,
+ srcBufferRange,
+ dstPictureResource,
+ pSetupReferenceSlot,
+ referenceSlotCount,
+ pReferenceSlots );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeInfoKHR const & ) const = default;
# else
bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) &&
- ( srcBuffer == rhs.srcBuffer ) && ( srcBufferOffset == rhs.srcBufferOffset ) &&
- ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) &&
- ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) &&
- ( pReferenceSlots == rhs.pReferenceSlots );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoDecodeInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR, seed, videoDecodeInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeInfoKHR.codedOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoDecodeInfoKHR.codedExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoDecodeInfoKHR.srcBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferRange );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoDecodeInfoKHR.dstPictureResource );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pSetupReferenceSlot );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeInfoKHR.referenceSlotCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pReferenceSlots );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT *>( this );
}
- operator VkVideoEncodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint8_t const &,
+ uint8_t const &,
+ uint8_t const &,
+ uint8_t const &,
+ VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ inputModeFlags,
+ outputModeFlags,
+ minPictureSizeInMbs,
+ maxPictureSizeInMbs,
+ inputImageDataAlignment,
+ maxNumL0ReferenceForP,
+ maxNumL0ReferenceForB,
+ maxNumL1Reference,
+ qualityLevelCount,
+ stdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) &&
- ( minPictureSizeInMbs == rhs.minPictureSizeInMbs ) && ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) &&
- ( inputImageDataAlignment == rhs.inputImageDataAlignment ) &&
- ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) &&
- ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) &&
- ( qualityLevelCount == rhs.qualityLevelCount ) && ( stdExtensionVersion == rhs.stdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264CapabilitiesEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const & videoEncodeH264CapabilitiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264CapabilitiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264CapabilitiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.inputModeFlags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.outputModeFlags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.minPictureSizeInMbs );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.maxPictureSizeInMbs );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.inputImageDataAlignment );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForP );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForB );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL1Reference );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.qualityLevelCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT *>( this );
}
- operator VkVideoEncodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ int8_t const &,
+ const StdVideoEncodeH264PictureInfo * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, slotIndex, pStdPictureInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264DpbSlotInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
- ( pStdPictureInfo == rhs.pStdPictureInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264DpbSlotInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const & videoEncodeH264DpbSlotInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264DpbSlotInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264DpbSlotInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH264DpbSlotInfoEXT.slotIndex );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoEncodeH264PictureInfo *, seed, videoEncodeH264DpbSlotInfoEXT.pStdPictureInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT *>( this );
}
- operator VkVideoEncodeH264EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint8_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ const uint8_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, spsId, emitSpsEnable, ppsIdEntryCount, ppsIdEntries );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264EmitPictureParametersEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsId == rhs.spsId ) &&
- ( emitSpsEnable == rhs.emitSpsEnable ) && ( ppsIdEntryCount == rhs.ppsIdEntryCount ) &&
- ( ppsIdEntries == rhs.ppsIdEntries );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264EmitPictureParametersEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT const &
- videoEncodeH264EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264EmitPictureParametersEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264EmitPictureParametersEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264EmitPictureParametersEXT.spsId );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264EmitPictureParametersEXT.emitSpsEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntryCount );
- VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264FrameSizeEXT *>( this );
}
- operator VkVideoEncodeH264FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264FrameSizeEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( frameISize, framePSize, frameBSize );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264FrameSizeEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
VULKAN_HPP_STATIC_ASSERT(
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>::value,
"VideoEncodeH264FrameSizeEXT is not nothrow_move_constructible!" );
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const & videoEncodeH264FrameSizeEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameISize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.framePSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameBSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264NaluSliceEXT *>( this );
}
- operator VkVideoEncodeH264NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264NaluSliceEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const StdVideoEncodeH264SliceHeader * const &,
+ uint32_t const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ pSliceHeaderStd,
+ mbCount,
+ refFinalList0EntryCount,
+ pRefFinalList0Entries,
+ refFinalList1EntryCount,
+ pRefFinalList1Entries );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264NaluSliceEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ) &&
- ( mbCount == rhs.mbCount ) && ( refFinalList0EntryCount == rhs.refFinalList0EntryCount ) &&
- ( pRefFinalList0Entries == rhs.pRefFinalList0Entries ) &&
- ( refFinalList1EntryCount == rhs.refFinalList1EntryCount ) &&
- ( pRefFinalList1Entries == rhs.pRefFinalList1Entries );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264NaluSliceEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT const & videoEncodeH264NaluSliceEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264NaluSliceEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264NaluSliceEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH264SliceHeader *, seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264NaluSliceEXT.mbCount );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList0EntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
- seed,
- videoEncodeH264NaluSliceEXT.pRefFinalList0Entries );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList1EntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
- seed,
- videoEncodeH264NaluSliceEXT.pRefFinalList1Entries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264ProfileEXT *>( this );
}
- operator VkVideoEncodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264ProfileEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH264ProfileIdc const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stdProfileIdc );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264ProfileEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264ProfileEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT const & videoEncodeH264ProfileEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264ProfileEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264ProfileEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoEncodeH264ProfileEXT.stdProfileIdc );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264QpEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264QpEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264QpEXT *>( this );
}
- operator VkVideoEncodeH264QpEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264QpEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264QpEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<int32_t const &, int32_t const &, int32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( qpI, qpP, qpB );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264QpEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>::value,
"VideoEncodeH264QpEXT is not nothrow_move_constructible!" );
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & videoEncodeH264QpEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpI );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpP );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpB );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
uint32_t idrPeriod_ = {},
uint32_t consecutiveBFrameCount_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure_ =
- VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown,
+ uint8_t temporalLayerCount_ = {} ) VULKAN_HPP_NOEXCEPT
: gopFrameCount( gopFrameCount_ )
, idrPeriod( idrPeriod_ )
, consecutiveBFrameCount( consecutiveBFrameCount_ )
, rateControlStructure( rateControlStructure_ )
+ , temporalLayerCount( temporalLayerCount_ )
{}
VULKAN_HPP_CONSTEXPR
rateControlStructure = rateControlStructure_;
return *this;
}
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT &
+ setTemporalLayerCount( uint8_t temporalLayerCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ temporalLayerCount = temporalLayerCount_;
+ return *this;
+ }
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT *>( this );
}
- operator VkVideoEncodeH264RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT const &,
+ uint8_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264RateControlInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) &&
- ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) &&
- ( rateControlStructure == rhs.rateControlStructure );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
uint32_t consecutiveBFrameCount = {};
VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure =
VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown;
+ uint8_t temporalLayerCount = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT ) ==
sizeof( VkVideoEncodeH264RateControlInfoEXT ),
{
using Type = VideoEncodeH264RateControlInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const &
- videoEncodeH264RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.gopFrameCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.idrPeriod );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT,
- seed,
- videoEncodeH264RateControlInfoEXT.rateControlStructure );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT *>( this );
}
- operator VkVideoEncodeH264RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint8_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ temporalLayerId,
+ useInitialRcQp,
+ initialRcQp,
+ useMinQp,
+ minQp,
+ useMaxQp,
+ maxQp,
+ useMaxFrameSize,
+ maxFrameSize );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264RateControlLayerInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) &&
- ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) &&
- ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
- ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) &&
- ( maxFrameSize == rhs.maxFrameSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264RateControlLayerInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const &
- videoEncodeH264RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlLayerInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlLayerInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.minQp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT *>( this );
}
- operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, maxPictureSizeInMbs, pStdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264SessionCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264SessionCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const &
- videoEncodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT, seed, videoEncodeH264SessionCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264SessionCreateInfoEXT.maxPictureSizeInMbs );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
- seed,
- videoEncodeH264SessionCreateInfoEXT.pStdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT *>( this );
}
- operator VkVideoEncodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const StdVideoH264SequenceParameterSet * const &,
+ uint32_t const &,
+ const StdVideoH264PictureParameterSet * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264SessionParametersAddInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
- ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264SessionParametersAddInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const &
- videoEncodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersAddInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersAddInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.spsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH264SequenceParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pSpsStd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.ppsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH264PictureParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pPpsStd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT *>( this );
}
- operator VkVideoEncodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264SessionParametersCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
- ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264SessionParametersCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const &
- videoEncodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxSpsStdCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxPpsStdCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT *,
- seed,
- videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT *>( this );
}
- operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ refDefaultFinalList0EntryCount,
+ pRefDefaultFinalList0Entries,
+ refDefaultFinalList1EntryCount,
+ pRefDefaultFinalList1Entries,
+ naluSliceEntryCount,
+ pNaluSliceEntries,
+ pCurrentPictureInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( refDefaultFinalList0EntryCount == rhs.refDefaultFinalList0EntryCount ) &&
- ( pRefDefaultFinalList0Entries == rhs.pRefDefaultFinalList0Entries ) &&
- ( refDefaultFinalList1EntryCount == rhs.refDefaultFinalList1EntryCount ) &&
- ( pRefDefaultFinalList1Entries == rhs.pRefDefaultFinalList1Entries ) &&
- ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
- ( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH264VclFrameInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const & videoEncodeH264VclFrameInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264VclFrameInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264VclFrameInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList0EntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
- seed,
- videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList0Entries );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList1EntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
- seed,
- videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList1Entries );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT *,
- seed,
- videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *,
- seed,
- videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT *>( this );
}
- operator VkVideoEncodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ uint8_t const &,
+ uint8_t const &,
+ uint8_t const &,
+ uint8_t const &,
+ uint8_t const &,
+ VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ inputModeFlags,
+ outputModeFlags,
+ ctbSizes,
+ inputImageDataAlignment,
+ maxNumL0ReferenceForP,
+ maxNumL0ReferenceForB,
+ maxNumL1Reference,
+ maxNumSubLayers,
+ qualityLevelCount,
+ stdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) &&
- ( ctbSizes == rhs.ctbSizes ) && ( inputImageDataAlignment == rhs.inputImageDataAlignment ) &&
- ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) &&
- ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) &&
- ( maxNumSubLayers == rhs.maxNumSubLayers ) && ( qualityLevelCount == rhs.qualityLevelCount ) &&
- ( stdExtensionVersion == rhs.stdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265CapabilitiesEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const & videoEncodeH265CapabilitiesEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265CapabilitiesEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265CapabilitiesEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.flags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.inputModeFlags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.outputModeFlags );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.ctbSizes );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH265CapabilitiesEXT.inputImageDataAlignment );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForP );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForB );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL1Reference );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumSubLayers );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.qualityLevelCount );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH265CapabilitiesEXT.stdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT *>( this );
}
- operator VkVideoEncodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ int8_t const &,
+ const StdVideoEncodeH265ReferenceInfo * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, slotIndex, pStdReferenceInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265DpbSlotInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
- ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265DpbSlotInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const & videoEncodeH265DpbSlotInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265DpbSlotInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265DpbSlotInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH265DpbSlotInfoEXT.slotIndex );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoEncodeH265ReferenceInfo *, seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT *>( this );
}
- operator VkVideoEncodeH265EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint8_t const &,
+ uint8_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ const uint8_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, vpsId, spsId, emitVpsEnable, emitSpsEnable, ppsIdEntryCount, ppsIdEntries );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265EmitPictureParametersEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsId == rhs.vpsId ) && ( spsId == rhs.spsId ) &&
- ( emitVpsEnable == rhs.emitVpsEnable ) && ( emitSpsEnable == rhs.emitSpsEnable ) &&
- ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && ( ppsIdEntries == rhs.ppsIdEntries );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265EmitPictureParametersEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT const &
- videoEncodeH265EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265EmitPictureParametersEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265EmitPictureParametersEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.vpsId );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.spsId );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitVpsEnable );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitSpsEnable );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntryCount );
- VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntries );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265FrameSizeEXT *>( this );
}
- operator VkVideoEncodeH265FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265FrameSizeEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265FrameSizeEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( frameISize, framePSize, frameBSize );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265FrameSizeEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
VULKAN_HPP_STATIC_ASSERT(
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>::value,
"VideoEncodeH265FrameSizeEXT is not nothrow_move_constructible!" );
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & videoEncodeH265FrameSizeEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameISize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.framePSize );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameBSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265ReferenceListsEXT *>( this );
}
- operator VkVideoEncodeH265ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265ReferenceListsEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT * const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT * const &,
+ const StdVideoEncodeH265ReferenceModifications * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ referenceList0EntryCount,
+ pReferenceList0Entries,
+ referenceList1EntryCount,
+ pReferenceList1Entries,
+ pReferenceModifications );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265ReferenceListsEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( referenceList0EntryCount == rhs.referenceList0EntryCount ) &&
- ( pReferenceList0Entries == rhs.pReferenceList0Entries ) &&
- ( referenceList1EntryCount == rhs.referenceList1EntryCount ) &&
- ( pReferenceList1Entries == rhs.pReferenceList1Entries ) &&
- ( pReferenceModifications == rhs.pReferenceModifications );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265ReferenceListsEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT const & videoEncodeH265ReferenceListsEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ReferenceListsEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ReferenceListsEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList0EntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *,
- seed,
- videoEncodeH265ReferenceListsEXT.pReferenceList0Entries );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList1EntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *,
- seed,
- videoEncodeH265ReferenceListsEXT.pReferenceList1Entries );
- VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265ReferenceModifications *,
- seed,
- videoEncodeH265ReferenceListsEXT.pReferenceModifications );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265NaluSliceEXT *>( this );
}
- operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265NaluSliceEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
+ const StdVideoEncodeH265SliceHeader * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) &&
- ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265NaluSliceEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT const & videoEncodeH265NaluSliceEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265NaluSliceEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265NaluSliceEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265NaluSliceEXT.ctbCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *,
- seed,
- videoEncodeH265NaluSliceEXT.pReferenceFinalLists );
- VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265SliceHeader *, seed, videoEncodeH265NaluSliceEXT.pSliceHeaderStd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265ProfileEXT *>( this );
}
- operator VkVideoEncodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265ProfileEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, stdProfileIdc );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265ProfileEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265ProfileEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT const & videoEncodeH265ProfileEXT ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ProfileEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ProfileEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoEncodeH265ProfileEXT.stdProfileIdc );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265QpEXT *>( this );
}
- operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265QpEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<int32_t const &, int32_t const &, int32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( qpI, qpP, qpB );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265QpEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>::value,
"VideoEncodeH265QpEXT is not nothrow_move_constructible!" );
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & videoEncodeH265QpEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpI );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpP );
- VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpB );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
uint32_t idrPeriod_ = {},
uint32_t consecutiveBFrameCount_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure_ =
- VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown,
+ uint8_t subLayerCount_ = {} ) VULKAN_HPP_NOEXCEPT
: gopFrameCount( gopFrameCount_ )
, idrPeriod( idrPeriod_ )
, consecutiveBFrameCount( consecutiveBFrameCount_ )
, rateControlStructure( rateControlStructure_ )
+ , subLayerCount( subLayerCount_ )
{}
VULKAN_HPP_CONSTEXPR
rateControlStructure = rateControlStructure_;
return *this;
}
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT &
+ setSubLayerCount( uint8_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ subLayerCount = subLayerCount_;
+ return *this;
+ }
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT *>( this );
}
- operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT const &,
+ uint8_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) &&
- ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) &&
- ( rateControlStructure == rhs.rateControlStructure );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
uint32_t consecutiveBFrameCount = {};
VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure =
VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown;
+ uint8_t subLayerCount = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT ) ==
sizeof( VkVideoEncodeH265RateControlInfoEXT ),
{
using Type = VideoEncodeH265RateControlInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const &
- videoEncodeH265RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.gopFrameCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.idrPeriod );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT,
- seed,
- videoEncodeH265RateControlInfoEXT.rateControlStructure );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
}
- operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint8_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ temporalId,
+ useInitialRcQp,
+ initialRcQp,
+ useMinQp,
+ minQp,
+ useMaxQp,
+ maxQp,
+ useMaxFrameSize,
+ maxFrameSize );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) &&
- ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) &&
- ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
- ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) &&
- ( maxFrameSize == rhs.maxFrameSize );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265RateControlLayerInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const &
- videoEncodeH265RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlLayerInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlLayerInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265RateControlLayerInfoEXT.temporalId );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.minQp );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxQp );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT *>( this );
}
- operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT const &,
+ const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, pStdExtensionVersion );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265SessionCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265SessionCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const &
- videoEncodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT, seed, videoEncodeH265SessionCreateInfoEXT.flags );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *,
- seed,
- videoEncodeH265SessionCreateInfoEXT.pStdExtensionVersion );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
}
- operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const StdVideoH265VideoParameterSet * const &,
+ uint32_t const &,
+ const StdVideoH265SequenceParameterSet * const &,
+ uint32_t const &,
+ const StdVideoH265PictureParameterSet * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, vpsStdCount, pVpsStd, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsStdCount == rhs.vpsStdCount ) &&
- ( pVpsStd == rhs.pVpsStd ) && ( spsStdCount == rhs.spsStdCount ) && ( pSpsStd == rhs.pSpsStd ) &&
- ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265SessionParametersAddInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const &
- videoEncodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersAddInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersAddInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.vpsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH265VideoParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pVpsStd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.spsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH265SequenceParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pSpsStd );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.ppsStdCount );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoH265PictureParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pPpsStd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
}
- operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxVpsStdCount, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVpsStdCount == rhs.maxVpsStdCount ) &&
- ( maxSpsStdCount == rhs.maxSpsStdCount ) && ( maxPpsStdCount == rhs.maxPpsStdCount ) &&
- ( pParametersAddInfo == rhs.pParametersAddInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265SessionParametersCreateInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const &
- videoEncodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersCreateInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxVpsStdCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxSpsStdCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxPpsStdCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT *,
- seed,
- videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT *>( this );
}
- operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * const &,
+ const StdVideoEncodeH265PictureInfo * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie(
+ sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) &&
- ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
- ( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeH265VclFrameInfoEXT;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const & videoEncodeH265VclFrameInfoEXT )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265VclFrameInfoEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265VclFrameInfoEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *,
- seed,
- videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265VclFrameInfoEXT.naluSliceEntryCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT *,
- seed,
- videoEncodeH265VclFrameInfoEXT.pNaluSliceEntries );
- VULKAN_HPP_HASH_COMBINE(
- const StdVideoEncodeH265PictureInfo *, seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeInfoKHR *>( this );
}
- operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ qualityLevel,
+ codedExtent,
+ dstBitstreamBuffer,
+ dstBitstreamBufferOffset,
+ dstBitstreamBufferMaxRange,
+ srcPictureResource,
+ pSetupReferenceSlot,
+ referenceSlotCount,
+ pReferenceSlots,
+ precedingExternallyEncodedBytes );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeInfoKHR const & ) const = default;
# else
bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( qualityLevel == rhs.qualityLevel ) && ( codedExtent == rhs.codedExtent ) &&
- ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) &&
- ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) &&
- ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) &&
- ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) &&
- ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) &&
- ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR, seed, videoEncodeInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.qualityLevel );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeInfoKHR.codedExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoEncodeInfoKHR.dstBitstreamBuffer );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferOffset );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoEncodeInfoKHR.srcPictureResource );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pSetupReferenceSlot );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.referenceSlotCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pReferenceSlots );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR *>( this );
}
- operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ averageBitrate,
+ maxBitrate,
+ frameRateNumerator,
+ frameRateDenominator,
+ virtualBufferSizeInMs,
+ initialVirtualBufferSizeInMs );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default;
# else
bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) &&
- ( maxBitrate == rhs.maxBitrate ) && ( frameRateNumerator == rhs.frameRateNumerator ) &&
- ( frameRateDenominator == rhs.frameRateDenominator ) &&
- ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) &&
- ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeRateControlLayerInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const &
- videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlLayerInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlLayerInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.averageBitrate );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.maxBitrate );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>( this );
}
- operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeRateControlInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR const &,
+ uint8_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayerConfigs );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default;
# else
bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( rateControlMode == rhs.rateControlMode ) && ( layerCount == rhs.layerCount ) &&
- ( pLayerConfigs == rhs.pLayerConfigs );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEncodeRateControlInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR, seed, videoEncodeRateControlInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR,
- seed,
- videoEncodeRateControlInfoKHR.rateControlMode );
- VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeRateControlInfoKHR.layerCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR *,
- seed,
- videoEncodeRateControlInfoKHR.pLayerConfigs );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEndCodingInfoKHR *>( this );
}
- operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEndCodingInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEndCodingInfoKHR const & ) const = default;
# else
bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoEndCodingInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEndCodingInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEndCodingInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR, seed, videoEndCodingInfoKHR.flags );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
return *this;
}
- operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoFormatPropertiesKHR *>( this );
}
- operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoFormatPropertiesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Format const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, format );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoFormatPropertiesKHR const & ) const = default;
# else
bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoFormatPropertiesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoFormatPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoFormatPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoFormatPropertiesKHR.format );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoGetMemoryPropertiesKHR *>( this );
}
- operator VkVideoGetMemoryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoGetMemoryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::MemoryRequirements2 * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, memoryBindIndex, pMemoryRequirements );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoGetMemoryPropertiesKHR const & ) const = default;
# else
bool operator==( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) &&
- ( pMemoryRequirements == rhs.pMemoryRequirements );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoGetMemoryPropertiesKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR const & videoGetMemoryPropertiesKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoGetMemoryPropertiesKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoGetMemoryPropertiesKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoGetMemoryPropertiesKHR.memoryBindIndex );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::MemoryRequirements2 *, seed, videoGetMemoryPropertiesKHR.pMemoryRequirements );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoQueueFamilyProperties2KHR *>( this );
}
- operator VkVideoQueueFamilyProperties2KHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoQueueFamilyProperties2KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoQueueFamilyProperties2KHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, videoCodecOperations );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoQueueFamilyProperties2KHR const & ) const = default;
# else
bool operator==( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoQueueFamilyProperties2KHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR const & videoQueueFamilyProperties2KHR )
- const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoQueueFamilyProperties2KHR.sType );
- VULKAN_HPP_HASH_COMBINE( void *, seed, videoQueueFamilyProperties2KHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR, seed, videoQueueFamilyProperties2KHR.videoCodecOperations );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( this );
}
- operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoSessionCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR const &,
+ const VULKAN_HPP_NAMESPACE::VideoProfileKHR * const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
+ VULKAN_HPP_NAMESPACE::Format const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ queueFamilyIndex,
+ flags,
+ pVideoProfile,
+ pictureFormat,
+ maxCodedExtent,
+ referencePicturesFormat,
+ maxReferencePicturesSlotsCount,
+ maxReferencePicturesActiveCount );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default;
# else
bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
- ( flags == rhs.flags ) && ( pVideoProfile == rhs.pVideoProfile ) &&
- ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) &&
- ( referencePicturesFormat == rhs.referencePicturesFormat ) &&
- ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) &&
- ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoSessionCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.queueFamilyIndex );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR, seed, videoSessionCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoSessionCreateInfoKHR.pVideoProfile );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.pictureFormat );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoSessionCreateInfoKHR.maxCodedExtent );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.referencePicturesFormat );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesSlotsCount );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesActiveCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( this );
}
- operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoSessionParametersCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoSessionKHR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, videoSessionParametersTemplate, videoSession );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default;
# else
bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) &&
- ( videoSession == rhs.videoSession );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoSessionParametersCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &
- videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR,
- seed,
- videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoSessionParametersCreateInfoKHR.videoSession );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( this );
}
- operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, updateSequenceCount );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default;
# else
bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = VideoSessionParametersUpdateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const &
- videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersUpdateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersUpdateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( this );
}
- operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR const &,
+ struct wl_display * const &,
+ struct wl_surface * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, display, surface );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default;
# else
bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) &&
- ( surface == rhs.surface );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = WaylandSurfaceCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, waylandSurfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, waylandSurfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR, seed, waylandSurfaceCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( struct wl_display *, seed, waylandSurfaceCreateInfoKHR.display );
- VULKAN_HPP_HASH_COMBINE( struct wl_surface *, seed, waylandSurfaceCreateInfoKHR.surface );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>( this );
}
- operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+ const uint64_t * const &,
+ const uint32_t * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+ const uint64_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ acquireCount,
+ pAcquireSyncs,
+ pAcquireKeys,
+ pAcquireTimeouts,
+ releaseCount,
+ pReleaseSyncs,
+ pReleaseKeys );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default;
# else
bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) &&
- ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) &&
- ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) &&
- ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = Win32KeyedMutexAcquireReleaseInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const &
- win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>( this );
}
- operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+ const uint64_t * const &,
+ const uint32_t * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
+ const uint64_t * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ acquireCount,
+ pAcquireSyncs,
+ pAcquireKeys,
+ pAcquireTimeoutMilliseconds,
+ releaseCount,
+ pReleaseSyncs,
+ pReleaseKeys );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default;
# else
bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) &&
- ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) &&
- ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) &&
- ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) &&
- ( pReleaseKeys == rhs.pReleaseKeys );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = Win32KeyedMutexAcquireReleaseInfoNV;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const &
- win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys );
- VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount );
- VULKAN_HPP_HASH_COMBINE(
- const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs );
- VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( this );
}
- operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR const &,
+ HINSTANCE const &,
+ HWND const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, hinstance, hwnd );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default;
# else
bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = Win32SurfaceCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32SurfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, win32SurfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR, seed, win32SurfaceCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( HINSTANCE, seed, win32SurfaceCreateInfoKHR.hinstance );
- VULKAN_HPP_HASH_COMBINE( HWND, seed, win32SurfaceCreateInfoKHR.hwnd );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct WriteDescriptorSet
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWriteDescriptorSet *>( this );
}
- operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWriteDescriptorSet *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::DescriptorSet const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::DescriptorType const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorImageInfo * const &,
+ const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo * const &,
+ const VULKAN_HPP_NAMESPACE::BufferView * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ dstSet,
+ dstBinding,
+ dstArrayElement,
+ descriptorCount,
+ descriptorType,
+ pImageInfo,
+ pBufferInfo,
+ pTexelBufferView );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( WriteDescriptorSet const & ) const = default;
#else
bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( 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 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = WriteDescriptorSet;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
-{
- std::size_t
- operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSet.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSet.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, writeDescriptorSet.dstSet );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstBinding );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstArrayElement );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.descriptorCount );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, writeDescriptorSet.descriptorType );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorImageInfo *, seed, writeDescriptorSet.pImageInfo );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo *, seed, writeDescriptorSet.pBufferInfo );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferView *, seed, writeDescriptorSet.pTexelBufferView );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct WriteDescriptorSetAccelerationStructureKHR
{
using NativeType = VkWriteDescriptorSetAccelerationStructureKHR;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>( this );
}
- operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default;
#else
bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
- ( pAccelerationStructures == rhs.pAccelerationStructures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = WriteDescriptorSetAccelerationStructureKHR;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const &
- writeDescriptorSetAccelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *,
- seed,
- writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct WriteDescriptorSetAccelerationStructureNV
{
using NativeType = VkWriteDescriptorSetAccelerationStructureNV;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>( this );
}
- operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default;
#else
bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
- ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
- ( pAccelerationStructures == rhs.pAccelerationStructures );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = WriteDescriptorSetAccelerationStructureNV;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const &
- writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE(
- VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureNV.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureNV.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount );
- VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *,
- seed,
- writeDescriptorSetAccelerationStructureNV.pAccelerationStructures );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
struct WriteDescriptorSetInlineUniformBlockEXT
{
using NativeType = VkWriteDescriptorSetInlineUniformBlockEXT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT *>( this );
}
- operator VkWriteDescriptorSetInlineUniformBlockEXT &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkWriteDescriptorSetInlineUniformBlockEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT *>( this );
}
+#if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+#else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const void * const &>
+#endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, dataSize, pData );
+ }
+
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const & ) const = default;
#else
bool operator==( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
#endif
using Type = WriteDescriptorSetInlineUniformBlockEXT;
};
-} // namespace VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT const &
- writeDescriptorSetInlineUniformBlockEXT ) const VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetInlineUniformBlockEXT.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pNext );
- VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetInlineUniformBlockEXT.dataSize );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pData );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#if defined( VK_USE_PLATFORM_XCB_KHR )
struct XcbSurfaceCreateInfoKHR
{
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( this );
}
- operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR const &,
+ xcb_connection_t * const &,
+ xcb_window_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, connection, window );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( XcbSurfaceCreateInfoKHR const & ) const = default;
# else
bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
- ( connection == rhs.connection ) && ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = XcbSurfaceCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xcbSurfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, xcbSurfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR, seed, xcbSurfaceCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( xcb_connection_t *, seed, xcbSurfaceCreateInfoKHR.connection );
- VULKAN_HPP_HASH_COMBINE( xcb_window_t, seed, xcbSurfaceCreateInfoKHR.window );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_XLIB_KHR )
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ explicit operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( this );
}
- operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ explicit operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>( this );
}
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR const &,
+ Display * const &,
+ Window const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, dpy, window );
+ }
+
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( XlibSurfaceCreateInfoKHR const & ) const = default;
# else
bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) &&
- ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 );
+ return this->reflect() == rhs.reflect();
}
bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- return !operator==( rhs );
+ return this->reflect() != rhs.reflect();
}
# endif
{
using Type = XlibSurfaceCreateInfoKHR;
};
-
-} // VULKAN_HPP_NAMESPACE
-
-template <>
-struct std::hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
-{
- std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const
- VULKAN_HPP_NOEXCEPT
- {
- std::size_t seed = 0;
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xlibSurfaceCreateInfoKHR.sType );
- VULKAN_HPP_HASH_COMBINE( const void *, seed, xlibSurfaceCreateInfoKHR.pNext );
- VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR, seed, xlibSurfaceCreateInfoKHR.flags );
- VULKAN_HPP_HASH_COMBINE( Display *, seed, xlibSurfaceCreateInfoKHR.dpy );
- VULKAN_HPP_HASH_COMBINE( Window, seed, xlibSurfaceCreateInfoKHR.window );
- return seed;
- }
-};
-
-namespace VULKAN_HPP_NAMESPACE
-{
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
} // namespace VULKAN_HPP_NAMESPACE
projects / platform / upstream / Vulkan-Headers.git / commitdiff