mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #960 from asuessenbach/178

Browse Source 
Update to VK_HEADER_VERSION 178.
This commit is contained in:
Andreas Süßenbach 2021-05-11 13:51:02 +02:00 committed by GitHub
commit c92c47c3a4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 1268 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit 3f437c4a94ae35af1eb93700d073e9d0e7adab3d Subproject commit 9af411e83fb08cd2bddc3ec771de89416a96cb91

34
VulkanHppGenerator.cpp
View File

@ -18,7 +18,6 @@
#include <fstream> #include <fstream>
#include <regex> #include <regex>
void appendVersionCheck( std::string & str, std::string const & version );
bool beginsWith( std::string const & text, std::string const & prefix ); bool beginsWith( std::string const & text, std::string const & prefix );
bool endsWith( std::string const & text, std::string const & postfix ); bool endsWith( std::string const & text, std::string const & postfix );
void check( bool condition, int line, std::string const & message ); void check( bool condition, int line, std::string const & message );
@ -44,7 +43,6 @@ std::string determineNoDiscard( bool multiSuccessCodes, bool multiErrorCode
std::set<size_t> determineSingularParams( size_t returnParamIndex, std::set<size_t> determineSingularParams( size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices ); std::map<size_t, size_t> const & vectorParamIndices );
std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices ); std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices );
std::string extractTag( int line, std::string const & name, std::set<std::string> const & tags );
std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" ); std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" );
std::map<std::string, std::string> getAttributes( tinyxml2::XMLElement const * element ); std::map<std::string, std::string> getAttributes( tinyxml2::XMLElement const * element );
template <typename ElementContainer> template <typename ElementContainer>
@ -84,13 +82,6 @@ const std::set<std::string> specialPointerTypes = {
"Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window" "Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window"
}; };
void appendVersionCheck( std::string & str, std::string const & version )
{
str += "static_assert( VK_HEADER_VERSION == " + version +
" , \"Wrong VK_HEADER_VERSION!\" );\n"
"\n";
}
bool beginsWith( std::string const & text, std::string const & prefix ) bool beginsWith( std::string const & text, std::string const & prefix )
{ {
return prefix.empty() || text.substr( 0, prefix.length() ) == prefix; return prefix.empty() || text.substr( 0, prefix.length() ) == prefix;
@ -398,18 +389,6 @@ std::string getEnumPostfix( std::string const & name, std::set<std::string> cons
return postfix; return postfix;
} }
std::string extractTag( int line, std::string const & name, std::set<std::string> const & tags )
{
// extract the tag from the name, which is supposed to look like VK_<tag>_<other>
size_t tagStart = name.find( '_' );
check( tagStart != std::string::npos, line, "name <" + name + "> is missing an underscore '_'" );
size_t tagEnd = name.find( '_', tagStart + 1 );
check( tagEnd != std::string::npos, line, "name <" + name + "> is missing an underscore '_'" );
std::string tag = name.substr( tagStart + 1, tagEnd - tagStart - 1 );
check( tags.find( tag ) != tags.end(), line, "name <" + name + "> is using an unknown tag <" + tag + ">" );
return tag;
}
std::pair<std::vector<std::string>, std::string> readModifiers( tinyxml2::XMLNode const * node ) std::pair<std::vector<std::string>, std::string> readModifiers( tinyxml2::XMLNode const * node )
{ {
std::vector<std::string> arraySizes; std::vector<std::string> arraySizes;
@ -12975,7 +12954,14 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element )
"required extension <" + r + "> already listed" ); "required extension <" + r + "> already listed" );
} }
std::string tag = extractTag( line, name, m_tags ); // extract the tag from the name, which is supposed to look like VK_<tag>_<other>
size_t tagStart = name.find( '_' );
check( tagStart != std::string::npos, line, "name <" + name + "> is missing an underscore '_'" );
size_t tagEnd = name.find( '_', tagStart + 1 );
check( tagEnd != std::string::npos, line, "name <" + name + "> is missing an underscore '_'" );
std::string tag = name.substr( tagStart + 1, tagEnd - tagStart - 1 );
check( m_tags.find( tag ) != m_tags.end(), line, "name <" + name + "> is using an unknown tag <" + tag + ">" );
for ( auto child : children ) for ( auto child : children )
{ {
readExtensionRequire( child, pitb.first, tag ); readExtensionRequire( child, pitb.first, tag );
@ -16597,7 +16583,9 @@ namespace std
static const size_t estimatedLength = 4 * 1024 * 1024; static const size_t estimatedLength = 4 * 1024 * 1024;
str.reserve( estimatedLength ); str.reserve( estimatedLength );
str += generator.getVulkanLicenseHeader() + includes + "\n"; str += generator.getVulkanLicenseHeader() + includes + "\n";
appendVersionCheck( str, generator.getVersion() ); str += "static_assert( VK_HEADER_VERSION == " + generator.getVersion() +
" , \"Wrong VK_HEADER_VERSION!\" );\n"
"\n";
str += str +=
"// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.\n" "// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.\n"
"// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION\n" + "// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION\n" +

1092
vulkan/vulkan.hpp
View File

File diff suppressed because it is too large Load Diff

200
vulkan/vulkan_raii.hpp
View File

@ -596,6 +596,7 @@ namespace VULKAN_HPP_NAMESPACE
vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
vkCmdCopyQueryPoolResults = vkCmdCopyQueryPoolResults =
PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
vkCmdDebugMarkerBeginEXT = vkCmdDebugMarkerBeginEXT =
PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
@ -796,6 +797,8 @@ namespace VULKAN_HPP_NAMESPACE
vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
vkCreateComputePipelines = vkCreateComputePipelines =
PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
vkCreateDeferredOperationKHR = vkCreateDeferredOperationKHR =
PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
@ -865,6 +868,8 @@ namespace VULKAN_HPP_NAMESPACE
vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
vkDestroyDeferredOperationKHR = vkDestroyDeferredOperationKHR =
PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
vkDestroyDescriptorPool = vkDestroyDescriptorPool =
@ -1279,6 +1284,7 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0;
PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0;
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0;
PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0;
PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0;
@ -1402,6 +1408,8 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCreateBufferView vkCreateBufferView = 0; PFN_vkCreateBufferView vkCreateBufferView = 0;
PFN_vkCreateCommandPool vkCreateCommandPool = 0; PFN_vkCreateCommandPool vkCreateCommandPool = 0;
PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0;
PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0;
PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
@ -1445,6 +1453,8 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkDestroyBuffer vkDestroyBuffer = 0; PFN_vkDestroyBuffer vkDestroyBuffer = 0;
PFN_vkDestroyBufferView vkDestroyBufferView = 0; PFN_vkDestroyBufferView vkDestroyBufferView = 0;
PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0;
PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0;
PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
@ -3276,6 +3286,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_NAMESPACE::QueryResultFlags flags
VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT;
void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT; void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT;
@ -3750,6 +3762,184 @@ namespace VULKAN_HPP_NAMESPACE
CommandBuffers & operator=( CommandBuffers && rhs ) = default; CommandBuffers & operator=( CommandBuffers && rhs ) = default;
}; };
class CuFunctionNVX
{
public:
using CType = VkCuFunctionNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
public:
CuFunctionNVX(
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
: m_device( *device )
, m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
, m_dispatcher( device.getDispatcher() )
{
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkCreateCuFunctionNVX( static_cast<VkDevice>( *device ),
reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
m_allocator,
reinterpret_cast<VkCuFunctionNVX *>( &m_cuFunctionNVX ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
throwResultException( result, "vkCreateCuFunctionNVX" );
}
}
CuFunctionNVX(
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
VkCuFunctionNVX cuFunctionNVX,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
: m_cuFunctionNVX( cuFunctionNVX )
, m_device( *device )
, m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
, m_dispatcher( device.getDispatcher() )
{}
~CuFunctionNVX()
{
if ( m_cuFunctionNVX )
{
getDispatcher()->vkDestroyCuFunctionNVX(
m_device, static_cast<VkCuFunctionNVX>( m_cuFunctionNVX ), m_allocator );
}
}
CuFunctionNVX() = delete;
CuFunctionNVX( CuFunctionNVX const & ) = delete;
CuFunctionNVX( CuFunctionNVX && rhs )
: m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) )
, m_device( rhs.m_device )
, m_allocator( rhs.m_allocator )
, m_dispatcher( rhs.m_dispatcher )
{}
CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete;
CuFunctionNVX & operator =( CuFunctionNVX && rhs )
{
if ( this != &rhs )
{
getDispatcher()->vkDestroyCuFunctionNVX(
m_device, static_cast<VkCuFunctionNVX>( m_cuFunctionNVX ), m_allocator );
m_cuFunctionNVX = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} );
m_device = rhs.m_device;
m_allocator = rhs.m_allocator;
m_dispatcher = rhs.m_dispatcher;
}
return *this;
}
VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX;
}
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
{
return m_dispatcher;
}
private:
VULKAN_HPP_NAMESPACE::CuFunctionNVX m_cuFunctionNVX;
VkDevice m_device;
const VkAllocationCallbacks * m_allocator;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher;
};
class CuModuleNVX
{
public:
using CType = VkCuModuleNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
public:
CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
: m_device( *device )
, m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
, m_dispatcher( device.getDispatcher() )
{
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkCreateCuModuleNVX( static_cast<VkDevice>( *device ),
reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
m_allocator,
reinterpret_cast<VkCuModuleNVX *>( &m_cuModuleNVX ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
throwResultException( result, "vkCreateCuModuleNVX" );
}
}
CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
VkCuModuleNVX cuModuleNVX,
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
: m_cuModuleNVX( cuModuleNVX )
, m_device( *device )
, m_allocator( reinterpret_cast<const VkAllocationCallbacks *>(
static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) )
, m_dispatcher( device.getDispatcher() )
{}
~CuModuleNVX()
{
if ( m_cuModuleNVX )
{
getDispatcher()->vkDestroyCuModuleNVX( m_device, static_cast<VkCuModuleNVX>( m_cuModuleNVX ), m_allocator );
}
}
CuModuleNVX() = delete;
CuModuleNVX( CuModuleNVX const & ) = delete;
CuModuleNVX( CuModuleNVX && rhs )
: m_cuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) )
, m_device( rhs.m_device )
, m_allocator( rhs.m_allocator )
, m_dispatcher( rhs.m_dispatcher )
{}
CuModuleNVX & operator=( CuModuleNVX const & ) = delete;
CuModuleNVX & operator =( CuModuleNVX && rhs )
{
if ( this != &rhs )
{
getDispatcher()->vkDestroyCuModuleNVX( m_device, static_cast<VkCuModuleNVX>( m_cuModuleNVX ), m_allocator );
m_cuModuleNVX = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} );
m_device = rhs.m_device;
m_allocator = rhs.m_allocator;
m_dispatcher = rhs.m_dispatcher;
}
return *this;
}
VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX;
}
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
{
return m_dispatcher;
}
private:
VULKAN_HPP_NAMESPACE::CuModuleNVX m_cuModuleNVX;
VkDevice m_device;
const VkAllocationCallbacks * m_allocator;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher;
};
class DebugReportCallbackEXT class DebugReportCallbackEXT
{ {
public: public:
@ -11855,6 +12045,16 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkQueryResultFlags>( flags ) ); static_cast<VkQueryResultFlags>( flags ) );
} }
VULKAN_HPP_INLINE void
CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX &&
"Function <vkCmdCuLaunchKernelNVX> needs extension <VK_NVX_binary_import> enabled!" );
getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
}
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
{ {