From b0bfcfdab56c865c7b7a91da548fd6eba5d7af80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Tue, 9 Jul 2019 09:24:14 +0200 Subject: [PATCH] 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) --- VulkanHppGenerator.cpp | 18 +++ vulkan/vulkan.hpp | 303 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 321 insertions(+) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 665db34..0db990c 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -3455,6 +3455,8 @@ void VulkanHppGenerator::writeHandle(std::ostream & os, std::pair + struct cpp_type + { + using type = ${className}; + }; )"; os << replaceWithMap(templateString, { @@ -4810,8 +4818,10 @@ int main( int argc, char **argv ) #if defined(_MSC_VER) && (_MSC_VER <= 1800) # define VULKAN_HPP_CONSTEXPR +# define VULKAN_HPP_CONST_OR_CONSTEXPR const #else # define VULKAN_HPP_CONSTEXPR constexpr +# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr #endif #if !defined(VULKAN_HPP_NAMESPACE) @@ -5052,6 +5062,13 @@ namespace std #endif )"; + static const std::string typeTraits = R"( + template + struct cpp_type + { + }; +)"; + try { tinyxml2::XMLDocument doc; @@ -5150,6 +5167,7 @@ namespace std << std::endl; generator.writeBaseTypes(ofs); generator.writeEnums(ofs); + ofs << typeTraits; generator.writeBitmasks(ofs); ofs << "} // namespace VULKAN_HPP_NAMESPACE" << std::endl << is_error_code_enum diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 2f2714f..ba86939 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -123,8 +123,10 @@ static_assert( VK_HEADER_VERSION == 108 , "Wrong VK_HEADER_VERSION!" ); #if defined(_MSC_VER) && (_MSC_VER <= 1800) # define VULKAN_HPP_CONSTEXPR +# define VULKAN_HPP_CONST_OR_CONSTEXPR const #else # define VULKAN_HPP_CONSTEXPR constexpr +# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr #endif #if !defined(VULKAN_HPP_NAMESPACE) @@ -5780,6 +5782,11 @@ namespace VULKAN_HPP_NAMESPACE } } + template + struct cpp_type + { + }; + enum class AccessFlagBits { eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, @@ -11348,6 +11355,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSurfaceKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; + public: VULKAN_HPP_CONSTEXPR SurfaceKHR() : 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!" ); + template <> + struct cpp_type + { + using type = SurfaceKHR; + }; + class DebugReportCallbackEXT { public: using CType = VkDebugReportCallbackEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; + public: VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() : 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!" ); + template <> + struct cpp_type + { + using type = DebugReportCallbackEXT; + }; + class DebugUtilsMessengerEXT { public: using CType = VkDebugUtilsMessengerEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; + public: VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() : 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!" ); + template <> + struct cpp_type + { + using type = DebugUtilsMessengerEXT; + }; + class DisplayKHR { public: using CType = VkDisplayKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; + public: VULKAN_HPP_CONSTEXPR DisplayKHR() : 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!" ); + template <> + struct cpp_type + { + using type = DisplayKHR; + }; + class SwapchainKHR { public: using CType = VkSwapchainKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; + public: VULKAN_HPP_CONSTEXPR SwapchainKHR() : 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!" ); + template <> + struct cpp_type + { + using type = SwapchainKHR; + }; + class Semaphore { public: using CType = VkSemaphore; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; + public: VULKAN_HPP_CONSTEXPR Semaphore() : 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!" ); + template <> + struct cpp_type + { + using type = Semaphore; + }; + class Fence { public: using CType = VkFence; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; + public: VULKAN_HPP_CONSTEXPR Fence() : 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!" ); + template <> + struct cpp_type + { + using type = Fence; + }; + class QueryPool { public: using CType = VkQueryPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; + public: VULKAN_HPP_CONSTEXPR QueryPool() : 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!" ); + template <> + struct cpp_type + { + using type = QueryPool; + }; + class Buffer { public: using CType = VkBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; + public: VULKAN_HPP_CONSTEXPR Buffer() : 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!" ); + template <> + struct cpp_type + { + using type = Buffer; + }; + class PipelineLayout { public: using CType = VkPipelineLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; + public: VULKAN_HPP_CONSTEXPR PipelineLayout() : 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!" ); + template <> + struct cpp_type + { + using type = PipelineLayout; + }; + class DescriptorSet { public: using CType = VkDescriptorSet; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; + public: VULKAN_HPP_CONSTEXPR DescriptorSet() : 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!" ); + template <> + struct cpp_type + { + using type = DescriptorSet; + }; + class Pipeline { public: using CType = VkPipeline; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; + public: VULKAN_HPP_CONSTEXPR Pipeline() : 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!" ); + template <> + struct cpp_type + { + using type = Pipeline; + }; + class ImageView { public: using CType = VkImageView; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; + public: VULKAN_HPP_CONSTEXPR ImageView() : 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!" ); + template <> + struct cpp_type + { + using type = ImageView; + }; + class Image { public: using CType = VkImage; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; + public: VULKAN_HPP_CONSTEXPR Image() : 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!" ); + template <> + struct cpp_type + { + using type = Image; + }; + class AccelerationStructureNV { public: using CType = VkAccelerationStructureNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV; + public: VULKAN_HPP_CONSTEXPR AccelerationStructureNV() : 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!" ); + template <> + struct cpp_type + { + using type = AccelerationStructureNV; + }; + class DescriptorUpdateTemplate { public: using CType = VkDescriptorUpdateTemplate; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; + public: VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() : m_descriptorUpdateTemplate(VK_NULL_HANDLE) @@ -12414,6 +12543,12 @@ namespace VULKAN_HPP_NAMESPACE VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; }; static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); + + template <> + struct cpp_type + { + using type = DescriptorUpdateTemplate; + }; using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; class Event @@ -12421,6 +12556,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkEvent; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; + public: VULKAN_HPP_CONSTEXPR Event() : 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!" ); + template <> + struct cpp_type + { + using type = Event; + }; + class CommandBuffer { public: using CType = VkCommandBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; + public: VULKAN_HPP_CONSTEXPR CommandBuffer() : 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!" ); + template <> + struct cpp_type + { + using type = CommandBuffer; + }; + class DeviceMemory { public: using CType = VkDeviceMemory; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; + public: VULKAN_HPP_CONSTEXPR DeviceMemory() : 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!" ); + template <> + struct cpp_type + { + using type = DeviceMemory; + }; + class BufferView { public: using CType = VkBufferView; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; + public: VULKAN_HPP_CONSTEXPR BufferView() : 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!" ); + template <> + struct cpp_type + { + using type = BufferView; + }; + class CommandPool { public: using CType = VkCommandPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; + public: VULKAN_HPP_CONSTEXPR CommandPool() : 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!" ); + template <> + struct cpp_type + { + using type = CommandPool; + }; + class PipelineCache { public: using CType = VkPipelineCache; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; + public: VULKAN_HPP_CONSTEXPR PipelineCache() : 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!" ); + template <> + struct cpp_type + { + using type = PipelineCache; + }; + class DescriptorPool { public: using CType = VkDescriptorPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; + public: VULKAN_HPP_CONSTEXPR DescriptorPool() : 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!" ); + template <> + struct cpp_type + { + using type = DescriptorPool; + }; + class DescriptorSetLayout { public: using CType = VkDescriptorSetLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; + public: VULKAN_HPP_CONSTEXPR DescriptorSetLayout() : 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!" ); + template <> + struct cpp_type + { + using type = DescriptorSetLayout; + }; + class Framebuffer { public: using CType = VkFramebuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; + public: VULKAN_HPP_CONSTEXPR Framebuffer() : 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!" ); + template <> + struct cpp_type + { + using type = Framebuffer; + }; + class IndirectCommandsLayoutNVX { public: using CType = VkIndirectCommandsLayoutNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNVX; + public: VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX() : 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!" ); + template <> + struct cpp_type + { + using type = IndirectCommandsLayoutNVX; + }; + class ObjectTableNVX { public: using CType = VkObjectTableNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eObjectTableNVX; + public: VULKAN_HPP_CONSTEXPR ObjectTableNVX() : 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!" ); + template <> + struct cpp_type + { + using type = ObjectTableNVX; + }; + class RenderPass { public: using CType = VkRenderPass; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; + public: VULKAN_HPP_CONSTEXPR RenderPass() : 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!" ); + template <> + struct cpp_type + { + using type = RenderPass; + }; + class Sampler { public: using CType = VkSampler; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; + public: VULKAN_HPP_CONSTEXPR Sampler() : 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!" ); + template <> + struct cpp_type + { + using type = Sampler; + }; + class SamplerYcbcrConversion { public: using CType = VkSamplerYcbcrConversion; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; + public: VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() : m_samplerYcbcrConversion(VK_NULL_HANDLE) @@ -13807,6 +14048,12 @@ namespace VULKAN_HPP_NAMESPACE VkSamplerYcbcrConversion m_samplerYcbcrConversion; }; static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); + + template <> + struct cpp_type + { + using type = SamplerYcbcrConversion; + }; using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; class ShaderModule @@ -13814,6 +14061,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkShaderModule; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; + public: VULKAN_HPP_CONSTEXPR ShaderModule() : 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!" ); + template <> + struct cpp_type + { + using type = ShaderModule; + }; + class ValidationCacheEXT { public: using CType = VkValidationCacheEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; + public: VULKAN_HPP_CONSTEXPR ValidationCacheEXT() : 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!" ); + template <> + struct cpp_type + { + using type = ValidationCacheEXT; + }; + class Queue { public: using CType = VkQueue; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; + public: VULKAN_HPP_CONSTEXPR Queue() : 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!" ); + template <> + struct cpp_type + { + using type = Queue; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Device; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; @@ -14130,6 +14401,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; + public: VULKAN_HPP_CONSTEXPR Device() : 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!" ); + template <> + struct cpp_type + { + using type = Device; + }; + class DisplayModeKHR { public: using CType = VkDisplayModeKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; + public: VULKAN_HPP_CONSTEXPR DisplayModeKHR() : 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!" ); + template <> + struct cpp_type + { + using type = DisplayModeKHR; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueDevice = UniqueHandle; @@ -15808,6 +16095,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPhysicalDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; + public: VULKAN_HPP_CONSTEXPR PhysicalDevice() : 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!" ); + template <> + struct cpp_type + { + using type = PhysicalDevice; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Instance; template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; @@ -16410,6 +16705,8 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; + public: VULKAN_HPP_CONSTEXPR Instance() : 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!" ); + template <> + struct cpp_type + { + using type = Instance; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; using UniqueInstance = UniqueHandle;