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

Add a static const(expr) member vk::ObjectType to the vk object classes; add a type_trait cpp_type<> to get the cpp-type from a vk::ObjectType. (#356)

Browse Source
This commit is contained in:
Andreas Süßenbach 2019-07-09 09:24:14 +02:00 committed by Markus Tavenrath
parent 712acf08f8
commit b0bfcfdab5
2 changed files with 321 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
VulkanHppGenerator.cpp
View File

@ -3455,6 +3455,8 @@ void VulkanHppGenerator::writeHandle(std::ostream & os, std::pair<std::string, H
public: public:
using CType = Vk${className}; using CType = Vk${className};
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::e${className};
public: public:
VULKAN_HPP_CONSTEXPR ${className}() VULKAN_HPP_CONSTEXPR ${className}()
: m_${memberName}(VK_NULL_HANDLE) : m_${memberName}(VK_NULL_HANDLE)
@ -3516,6 +3518,12 @@ ${commands}
Vk${className} m_${memberName}; Vk${className} m_${memberName};
}; };
static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" ); static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::e${className}>
{
using type = ${className};
};
)"; )";
os << replaceWithMap(templateString, { os << replaceWithMap(templateString, {
@ -4810,8 +4818,10 @@ int main( int argc, char **argv )
#if defined(_MSC_VER) && (_MSC_VER <= 1800) #if defined(_MSC_VER) && (_MSC_VER <= 1800)
# define VULKAN_HPP_CONSTEXPR # define VULKAN_HPP_CONSTEXPR
# define VULKAN_HPP_CONST_OR_CONSTEXPR const
#else #else
# define VULKAN_HPP_CONSTEXPR constexpr # define VULKAN_HPP_CONSTEXPR constexpr
# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
#endif #endif
#if !defined(VULKAN_HPP_NAMESPACE) #if !defined(VULKAN_HPP_NAMESPACE)
@ -5052,6 +5062,13 @@ namespace std
#endif #endif
)"; )";
static const std::string typeTraits = R"(
template<ObjectType value>
struct cpp_type
{
};
)";
try { try {
tinyxml2::XMLDocument doc; tinyxml2::XMLDocument doc;
@ -5150,6 +5167,7 @@ namespace std
<< std::endl; << std::endl;
generator.writeBaseTypes(ofs); generator.writeBaseTypes(ofs);
generator.writeEnums(ofs); generator.writeEnums(ofs);
ofs << typeTraits;
generator.writeBitmasks(ofs); generator.writeBitmasks(ofs);
ofs << "} // namespace VULKAN_HPP_NAMESPACE" << std::endl ofs << "} // namespace VULKAN_HPP_NAMESPACE" << std::endl
<< is_error_code_enum << is_error_code_enum

303
vulkan/vulkan.hpp
View File

@ -123,8 +123,10 @@ static_assert( VK_HEADER_VERSION == 108 , "Wrong VK_HEADER_VERSION!" );
#if defined(_MSC_VER) && (_MSC_VER <= 1800) #if defined(_MSC_VER) && (_MSC_VER <= 1800)
# define VULKAN_HPP_CONSTEXPR # define VULKAN_HPP_CONSTEXPR
# define VULKAN_HPP_CONST_OR_CONSTEXPR const
#else #else
# define VULKAN_HPP_CONSTEXPR constexpr # define VULKAN_HPP_CONSTEXPR constexpr
# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
#endif #endif
#if !defined(VULKAN_HPP_NAMESPACE) #if !defined(VULKAN_HPP_NAMESPACE)
@ -5780,6 +5782,11 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
template<ObjectType value>
struct cpp_type
{
};
enum class AccessFlagBits enum class AccessFlagBits
{ {
eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
@ -11348,6 +11355,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
using CType = VkSurfaceKHR; using CType = VkSurfaceKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR;
public: public:
VULKAN_HPP_CONSTEXPR SurfaceKHR() VULKAN_HPP_CONSTEXPR SurfaceKHR()
: m_surfaceKHR(VK_NULL_HANDLE) : m_surfaceKHR(VK_NULL_HANDLE)
@ -11410,11 +11419,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eSurfaceKHR>
{
using type = SurfaceKHR;
};
class DebugReportCallbackEXT class DebugReportCallbackEXT
{ {
public: public:
using CType = VkDebugReportCallbackEXT; using CType = VkDebugReportCallbackEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT;
public: public:
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
: m_debugReportCallbackEXT(VK_NULL_HANDLE) : m_debugReportCallbackEXT(VK_NULL_HANDLE)
@ -11477,11 +11494,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDebugReportCallbackEXT>
{
using type = DebugReportCallbackEXT;
};
class DebugUtilsMessengerEXT class DebugUtilsMessengerEXT
{ {
public: public:
using CType = VkDebugUtilsMessengerEXT; using CType = VkDebugUtilsMessengerEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT;
public: public:
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
: m_debugUtilsMessengerEXT(VK_NULL_HANDLE) : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
@ -11544,11 +11569,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDebugUtilsMessengerEXT>
{
using type = DebugUtilsMessengerEXT;
};
class DisplayKHR class DisplayKHR
{ {
public: public:
using CType = VkDisplayKHR; using CType = VkDisplayKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR;
public: public:
VULKAN_HPP_CONSTEXPR DisplayKHR() VULKAN_HPP_CONSTEXPR DisplayKHR()
: m_displayKHR(VK_NULL_HANDLE) : m_displayKHR(VK_NULL_HANDLE)
@ -11611,11 +11644,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDisplayKHR>
{
using type = DisplayKHR;
};
class SwapchainKHR class SwapchainKHR
{ {
public: public:
using CType = VkSwapchainKHR; using CType = VkSwapchainKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR;
public: public:
VULKAN_HPP_CONSTEXPR SwapchainKHR() VULKAN_HPP_CONSTEXPR SwapchainKHR()
: m_swapchainKHR(VK_NULL_HANDLE) : m_swapchainKHR(VK_NULL_HANDLE)
@ -11678,11 +11719,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eSwapchainKHR>
{
using type = SwapchainKHR;
};
class Semaphore class Semaphore
{ {
public: public:
using CType = VkSemaphore; using CType = VkSemaphore;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore;
public: public:
VULKAN_HPP_CONSTEXPR Semaphore() VULKAN_HPP_CONSTEXPR Semaphore()
: m_semaphore(VK_NULL_HANDLE) : m_semaphore(VK_NULL_HANDLE)
@ -11745,11 +11794,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eSemaphore>
{
using type = Semaphore;
};
class Fence class Fence
{ {
public: public:
using CType = VkFence; using CType = VkFence;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence;
public: public:
VULKAN_HPP_CONSTEXPR Fence() VULKAN_HPP_CONSTEXPR Fence()
: m_fence(VK_NULL_HANDLE) : m_fence(VK_NULL_HANDLE)
@ -11812,11 +11869,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eFence>
{
using type = Fence;
};
class QueryPool class QueryPool
{ {
public: public:
using CType = VkQueryPool; using CType = VkQueryPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool;
public: public:
VULKAN_HPP_CONSTEXPR QueryPool() VULKAN_HPP_CONSTEXPR QueryPool()
: m_queryPool(VK_NULL_HANDLE) : m_queryPool(VK_NULL_HANDLE)
@ -11879,11 +11944,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eQueryPool>
{
using type = QueryPool;
};
class Buffer class Buffer
{ {
public: public:
using CType = VkBuffer; using CType = VkBuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer;
public: public:
VULKAN_HPP_CONSTEXPR Buffer() VULKAN_HPP_CONSTEXPR Buffer()
: m_buffer(VK_NULL_HANDLE) : m_buffer(VK_NULL_HANDLE)
@ -11946,11 +12019,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eBuffer>
{
using type = Buffer;
};
class PipelineLayout class PipelineLayout
{ {
public: public:
using CType = VkPipelineLayout; using CType = VkPipelineLayout;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout;
public: public:
VULKAN_HPP_CONSTEXPR PipelineLayout() VULKAN_HPP_CONSTEXPR PipelineLayout()
: m_pipelineLayout(VK_NULL_HANDLE) : m_pipelineLayout(VK_NULL_HANDLE)
@ -12013,11 +12094,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::ePipelineLayout>
{
using type = PipelineLayout;
};
class DescriptorSet class DescriptorSet
{ {
public: public:
using CType = VkDescriptorSet; using CType = VkDescriptorSet;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet;
public: public:
VULKAN_HPP_CONSTEXPR DescriptorSet() VULKAN_HPP_CONSTEXPR DescriptorSet()
: m_descriptorSet(VK_NULL_HANDLE) : m_descriptorSet(VK_NULL_HANDLE)
@ -12080,11 +12169,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDescriptorSet>
{
using type = DescriptorSet;
};
class Pipeline class Pipeline
{ {
public: public:
using CType = VkPipeline; using CType = VkPipeline;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline;
public: public:
VULKAN_HPP_CONSTEXPR Pipeline() VULKAN_HPP_CONSTEXPR Pipeline()
: m_pipeline(VK_NULL_HANDLE) : m_pipeline(VK_NULL_HANDLE)
@ -12147,11 +12244,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::ePipeline>
{
using type = Pipeline;
};
class ImageView class ImageView
{ {
public: public:
using CType = VkImageView; using CType = VkImageView;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView;
public: public:
VULKAN_HPP_CONSTEXPR ImageView() VULKAN_HPP_CONSTEXPR ImageView()
: m_imageView(VK_NULL_HANDLE) : m_imageView(VK_NULL_HANDLE)
@ -12214,11 +12319,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eImageView>
{
using type = ImageView;
};
class Image class Image
{ {
public: public:
using CType = VkImage; using CType = VkImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
public: public:
VULKAN_HPP_CONSTEXPR Image() VULKAN_HPP_CONSTEXPR Image()
: m_image(VK_NULL_HANDLE) : m_image(VK_NULL_HANDLE)
@ -12281,11 +12394,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eImage>
{
using type = Image;
};
class AccelerationStructureNV class AccelerationStructureNV
{ {
public: public:
using CType = VkAccelerationStructureNV; using CType = VkAccelerationStructureNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV;
public: public:
VULKAN_HPP_CONSTEXPR AccelerationStructureNV() VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
: m_accelerationStructureNV(VK_NULL_HANDLE) : m_accelerationStructureNV(VK_NULL_HANDLE)
@ -12348,11 +12469,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" ); static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eAccelerationStructureNV>
{
using type = AccelerationStructureNV;
};
class DescriptorUpdateTemplate class DescriptorUpdateTemplate
{ {
public: public:
using CType = VkDescriptorUpdateTemplate; using CType = VkDescriptorUpdateTemplate;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate;
public: public:
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
: m_descriptorUpdateTemplate(VK_NULL_HANDLE) : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
@ -12414,6 +12543,12 @@ namespace VULKAN_HPP_NAMESPACE
VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
}; };
static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDescriptorUpdateTemplate>
{
using type = DescriptorUpdateTemplate;
};
using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
class Event class Event
@ -12421,6 +12556,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
using CType = VkEvent; using CType = VkEvent;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent;
public: public:
VULKAN_HPP_CONSTEXPR Event() VULKAN_HPP_CONSTEXPR Event()
: m_event(VK_NULL_HANDLE) : m_event(VK_NULL_HANDLE)
@ -12483,11 +12620,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eEvent>
{
using type = Event;
};
class CommandBuffer class CommandBuffer
{ {
public: public:
using CType = VkCommandBuffer; using CType = VkCommandBuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer;
public: public:
VULKAN_HPP_CONSTEXPR CommandBuffer() VULKAN_HPP_CONSTEXPR CommandBuffer()
: m_commandBuffer(VK_NULL_HANDLE) : m_commandBuffer(VK_NULL_HANDLE)
@ -13004,11 +13149,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eCommandBuffer>
{
using type = CommandBuffer;
};
class DeviceMemory class DeviceMemory
{ {
public: public:
using CType = VkDeviceMemory; using CType = VkDeviceMemory;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory;
public: public:
VULKAN_HPP_CONSTEXPR DeviceMemory() VULKAN_HPP_CONSTEXPR DeviceMemory()
: m_deviceMemory(VK_NULL_HANDLE) : m_deviceMemory(VK_NULL_HANDLE)
@ -13071,11 +13224,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDeviceMemory>
{
using type = DeviceMemory;
};
class BufferView class BufferView
{ {
public: public:
using CType = VkBufferView; using CType = VkBufferView;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView;
public: public:
VULKAN_HPP_CONSTEXPR BufferView() VULKAN_HPP_CONSTEXPR BufferView()
: m_bufferView(VK_NULL_HANDLE) : m_bufferView(VK_NULL_HANDLE)
@ -13138,11 +13299,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eBufferView>
{
using type = BufferView;
};
class CommandPool class CommandPool
{ {
public: public:
using CType = VkCommandPool; using CType = VkCommandPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool;
public: public:
VULKAN_HPP_CONSTEXPR CommandPool() VULKAN_HPP_CONSTEXPR CommandPool()
: m_commandPool(VK_NULL_HANDLE) : m_commandPool(VK_NULL_HANDLE)
@ -13205,11 +13374,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eCommandPool>
{
using type = CommandPool;
};
class PipelineCache class PipelineCache
{ {
public: public:
using CType = VkPipelineCache; using CType = VkPipelineCache;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache;
public: public:
VULKAN_HPP_CONSTEXPR PipelineCache() VULKAN_HPP_CONSTEXPR PipelineCache()
: m_pipelineCache(VK_NULL_HANDLE) : m_pipelineCache(VK_NULL_HANDLE)
@ -13272,11 +13449,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::ePipelineCache>
{
using type = PipelineCache;
};
class DescriptorPool class DescriptorPool
{ {
public: public:
using CType = VkDescriptorPool; using CType = VkDescriptorPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool;
public: public:
VULKAN_HPP_CONSTEXPR DescriptorPool() VULKAN_HPP_CONSTEXPR DescriptorPool()
: m_descriptorPool(VK_NULL_HANDLE) : m_descriptorPool(VK_NULL_HANDLE)
@ -13339,11 +13524,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDescriptorPool>
{
using type = DescriptorPool;
};
class DescriptorSetLayout class DescriptorSetLayout
{ {
public: public:
using CType = VkDescriptorSetLayout; using CType = VkDescriptorSetLayout;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout;
public: public:
VULKAN_HPP_CONSTEXPR DescriptorSetLayout() VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
: m_descriptorSetLayout(VK_NULL_HANDLE) : m_descriptorSetLayout(VK_NULL_HANDLE)
@ -13406,11 +13599,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDescriptorSetLayout>
{
using type = DescriptorSetLayout;
};
class Framebuffer class Framebuffer
{ {
public: public:
using CType = VkFramebuffer; using CType = VkFramebuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer;
public: public:
VULKAN_HPP_CONSTEXPR Framebuffer() VULKAN_HPP_CONSTEXPR Framebuffer()
: m_framebuffer(VK_NULL_HANDLE) : m_framebuffer(VK_NULL_HANDLE)
@ -13473,11 +13674,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eFramebuffer>
{
using type = Framebuffer;
};
class IndirectCommandsLayoutNVX class IndirectCommandsLayoutNVX
{ {
public: public:
using CType = VkIndirectCommandsLayoutNVX; using CType = VkIndirectCommandsLayoutNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNVX;
public: public:
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX() VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
: m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
@ -13540,11 +13749,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eIndirectCommandsLayoutNVX>
{
using type = IndirectCommandsLayoutNVX;
};
class ObjectTableNVX class ObjectTableNVX
{ {
public: public:
using CType = VkObjectTableNVX; using CType = VkObjectTableNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eObjectTableNVX;
public: public:
VULKAN_HPP_CONSTEXPR ObjectTableNVX() VULKAN_HPP_CONSTEXPR ObjectTableNVX()
: m_objectTableNVX(VK_NULL_HANDLE) : m_objectTableNVX(VK_NULL_HANDLE)
@ -13607,11 +13824,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eObjectTableNVX>
{
using type = ObjectTableNVX;
};
class RenderPass class RenderPass
{ {
public: public:
using CType = VkRenderPass; using CType = VkRenderPass;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass;
public: public:
VULKAN_HPP_CONSTEXPR RenderPass() VULKAN_HPP_CONSTEXPR RenderPass()
: m_renderPass(VK_NULL_HANDLE) : m_renderPass(VK_NULL_HANDLE)
@ -13674,11 +13899,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eRenderPass>
{
using type = RenderPass;
};
class Sampler class Sampler
{ {
public: public:
using CType = VkSampler; using CType = VkSampler;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler;
public: public:
VULKAN_HPP_CONSTEXPR Sampler() VULKAN_HPP_CONSTEXPR Sampler()
: m_sampler(VK_NULL_HANDLE) : m_sampler(VK_NULL_HANDLE)
@ -13741,11 +13974,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eSampler>
{
using type = Sampler;
};
class SamplerYcbcrConversion class SamplerYcbcrConversion
{ {
public: public:
using CType = VkSamplerYcbcrConversion; using CType = VkSamplerYcbcrConversion;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion;
public: public:
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
: m_samplerYcbcrConversion(VK_NULL_HANDLE) : m_samplerYcbcrConversion(VK_NULL_HANDLE)
@ -13807,6 +14048,12 @@ namespace VULKAN_HPP_NAMESPACE
VkSamplerYcbcrConversion m_samplerYcbcrConversion; VkSamplerYcbcrConversion m_samplerYcbcrConversion;
}; };
static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eSamplerYcbcrConversion>
{
using type = SamplerYcbcrConversion;
};
using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
class ShaderModule class ShaderModule
@ -13814,6 +14061,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
using CType = VkShaderModule; using CType = VkShaderModule;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule;
public: public:
VULKAN_HPP_CONSTEXPR ShaderModule() VULKAN_HPP_CONSTEXPR ShaderModule()
: m_shaderModule(VK_NULL_HANDLE) : m_shaderModule(VK_NULL_HANDLE)
@ -13876,11 +14125,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eShaderModule>
{
using type = ShaderModule;
};
class ValidationCacheEXT class ValidationCacheEXT
{ {
public: public:
using CType = VkValidationCacheEXT; using CType = VkValidationCacheEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT;
public: public:
VULKAN_HPP_CONSTEXPR ValidationCacheEXT() VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
: m_validationCacheEXT(VK_NULL_HANDLE) : m_validationCacheEXT(VK_NULL_HANDLE)
@ -13943,11 +14200,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eValidationCacheEXT>
{
using type = ValidationCacheEXT;
};
class Queue class Queue
{ {
public: public:
using CType = VkQueue; using CType = VkQueue;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue;
public: public:
VULKAN_HPP_CONSTEXPR Queue() VULKAN_HPP_CONSTEXPR Queue()
: m_queue(VK_NULL_HANDLE) : m_queue(VK_NULL_HANDLE)
@ -14065,6 +14330,12 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eQueue>
{
using type = Queue;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
class Device; class Device;
template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; }; template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
@ -14130,6 +14401,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
using CType = VkDevice; using CType = VkDevice;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice;
public: public:
VULKAN_HPP_CONSTEXPR Device() VULKAN_HPP_CONSTEXPR Device()
: m_device(VK_NULL_HANDLE) : m_device(VK_NULL_HANDLE)
@ -15731,11 +16004,19 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDevice>
{
using type = Device;
};
class DisplayModeKHR class DisplayModeKHR
{ {
public: public:
using CType = VkDisplayModeKHR; using CType = VkDisplayModeKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR;
public: public:
VULKAN_HPP_CONSTEXPR DisplayModeKHR() VULKAN_HPP_CONSTEXPR DisplayModeKHR()
: m_displayModeKHR(VK_NULL_HANDLE) : m_displayModeKHR(VK_NULL_HANDLE)
@ -15798,6 +16079,12 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eDisplayModeKHR>
{
using type = DisplayModeKHR;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; }; template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
using UniqueDevice = UniqueHandle<Device, DispatchLoaderDefault>; using UniqueDevice = UniqueHandle<Device, DispatchLoaderDefault>;
@ -15808,6 +16095,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
using CType = VkPhysicalDevice; using CType = VkPhysicalDevice;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice;
public: public:
VULKAN_HPP_CONSTEXPR PhysicalDevice() VULKAN_HPP_CONSTEXPR PhysicalDevice()
: m_physicalDevice(VK_NULL_HANDLE) : m_physicalDevice(VK_NULL_HANDLE)
@ -16395,6 +16684,12 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::ePhysicalDevice>
{
using type = PhysicalDevice;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
class Instance; class Instance;
template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; }; template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
@ -16410,6 +16705,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
using CType = VkInstance; using CType = VkInstance;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance;
public: public:
VULKAN_HPP_CONSTEXPR Instance() VULKAN_HPP_CONSTEXPR Instance()
: m_instance(VK_NULL_HANDLE) : m_instance(VK_NULL_HANDLE)
@ -16756,6 +17053,12 @@ namespace VULKAN_HPP_NAMESPACE
}; };
static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
template <>
struct cpp_type<ObjectType::eInstance>
{
using type = Instance;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; }; template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
using UniqueInstance = UniqueHandle<Instance, DispatchLoaderDefault>; using UniqueInstance = UniqueHandle<Instance, DispatchLoaderDefault>;