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

Introduce VULKAN_HPP_STATIC_ASSERT.

Browse Source
This commit is contained in:
asuessenbach 2021-09-07 13:47:18 +02:00
parent b97783be3e
commit dea1345852
5 changed files with 5475 additions and 2761 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -432,6 +432,9 @@ All over vulkan.hpp, there are a couple of calls to an assert function. By defin
By default, `VULKAN_HPP_ASSERT_ON_RESULT` will be used for checking results when `VULKAN_HPP_NO_EXCEPTIONS` is defined. If you want to handle errors by yourself, you can disable/customize it just like `VULKAN_HPP_ASSERT`. By default, `VULKAN_HPP_ASSERT_ON_RESULT` will be used for checking results when `VULKAN_HPP_NO_EXCEPTIONS` is defined. If you want to handle errors by yourself, you can disable/customize it just like `VULKAN_HPP_ASSERT`.
There are a couple of static assertions for each handle class and each struct. By defining `VULKAN_HPP_STATIC_ASSERT`, you can specify your own custom static assertion to be used for those cases. That is, by defining it to be a NOP, you can reduce your compilation time a little.
### Extensions / Per Device function pointers ### Extensions / Per Device function pointers
The Vulkan loader exposes only the Vulkan core functions and a limited number of extensions. To use Vulkan-Hpp with extensions it's required to have either a library which provides stubs to all used Vulkan functions or to tell Vulkan-Hpp to dispatch those functions pointers. Vulkan-Hpp provides a per-function dispatch mechanism by accepting a dispatch class as last parameter in each function call. The dispatch class must provide a callable type for each used Vulkan function. Vulkan-Hpp provides one implementation, ```DispatchLoaderDynamic```, which fetches all function pointers known to the library. The Vulkan loader exposes only the Vulkan core functions and a limited number of extensions. To use Vulkan-Hpp with extensions it's required to have either a library which provides stubs to all used Vulkan functions or to tell Vulkan-Hpp to dispatch those functions pointers. Vulkan-Hpp provides a per-function dispatch mechanism by accepting a dispatch class as last parameter in each function call. The dispatch class must provide a callable type for each used Vulkan function. Vulkan-Hpp provides one implementation, ```DispatchLoaderDynamic```, which fetches all function pointers known to the library.

12
VulkanHppGenerator.cpp
View File

@ -7457,7 +7457,8 @@ ${commands}
private: private:
Vk${className} m_${memberName} = {}; Vk${className} m_${memberName} = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" ); VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::${className}>::value, "${className} is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::${objTypeEnum}> struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::${objTypeEnum}>
@ -11858,8 +11859,9 @@ ${compareOperators}
public: public:
${members} ${members}
}; };
static_assert( sizeof( ${structureName} ) == sizeof( ${vkName} ), "struct and wrapper have different size!" ); VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::${structureName} ) == sizeof( ${vkName} ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<${structureName}>::value, "struct wrapper is not a standard layout!" ); VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::${structureName}>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::${structureName}>::value, "${structureName} is not nothrow_move_constructible!" );
)"; )";
std::string structureName = stripPrefix( structure.first, "Vk" ); std::string structureName = stripPrefix( structure.first, "Vk" );
@ -16613,6 +16615,10 @@ int main( int argc, char ** argv )
# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT # define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
#endif #endif
#if !defined( VULKAN_HPP_STATIC_ASSERT )
# define VULKAN_HPP_STATIC_ASSERT static_assert
#endif
#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL ) #if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 # define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
#endif #endif

4
vulkan/vulkan.hpp
View File

@ -79,6 +79,10 @@
# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT # define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
#endif #endif
#if !defined( VULKAN_HPP_STATIC_ASSERT )
# define VULKAN_HPP_STATIC_ASSERT static_assert
#endif
#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL ) #if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 # define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
#endif #endif

275
vulkan/vulkan_handles.hpp
View File

@ -1305,8 +1305,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkSurfaceKHR m_surfaceKHR = {}; VkSurfaceKHR m_surfaceKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceKHR>::value,
"SurfaceKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -1404,8 +1406,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDebugReportCallbackEXT m_debugReportCallbackEXT = {}; VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) ==
"handle and wrapper have different size!" ); sizeof( VkDebugReportCallbackEXT ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::value,
"DebugReportCallbackEXT is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -1503,8 +1508,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) ==
"handle and wrapper have different size!" ); sizeof( VkDebugUtilsMessengerEXT ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::value,
"DebugUtilsMessengerEXT is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -1593,8 +1601,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDisplayKHR m_displayKHR = {}; VkDisplayKHR m_displayKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayKHR>::value,
"DisplayKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -1691,8 +1701,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkSwapchainKHR m_swapchainKHR = {}; VkSwapchainKHR m_swapchainKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainKHR>::value,
"SwapchainKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -1787,8 +1799,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkSemaphore m_semaphore = {}; VkSemaphore m_semaphore = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Semaphore>::value,
"Semaphore is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -1883,8 +1897,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkFence m_fence = {}; VkFence m_fence = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Fence>::value,
"Fence is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFence> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFence>
@ -1981,9 +1997,12 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) == VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) ==
sizeof( VkPerformanceConfigurationINTEL ), sizeof( VkPerformanceConfigurationINTEL ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT(
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::value,
"PerformanceConfigurationINTEL is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2071,8 +2090,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkQueryPool m_queryPool = {}; VkQueryPool m_queryPool = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueryPool>::value,
"QueryPool is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2167,8 +2188,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkBuffer m_buffer = {}; VkBuffer m_buffer = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Buffer>::value,
"Buffer is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBuffer> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBuffer>
@ -2264,8 +2287,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkPipelineLayout m_pipelineLayout = {}; VkPipelineLayout m_pipelineLayout = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineLayout>::value,
"PipelineLayout is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2362,8 +2387,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDescriptorSet m_descriptorSet = {}; VkDescriptorSet m_descriptorSet = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSet>::value,
"DescriptorSet is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2458,8 +2485,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkImageView m_imageView = {}; VkImageView m_imageView = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageView>::value,
"ImageView is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2554,8 +2583,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkPipeline m_pipeline = {}; VkPipeline m_pipeline = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Pipeline>::value,
"Pipeline is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipeline> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipeline>
@ -2649,8 +2680,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkImage m_image = {}; VkImage m_image = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Image>::value,
"Image is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImage> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImage>
@ -2746,8 +2779,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkAccelerationStructureNV m_accelerationStructureNV = {}; VkAccelerationStructureNV m_accelerationStructureNV = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) ==
"handle and wrapper have different size!" ); sizeof( VkAccelerationStructureNV ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::value,
"AccelerationStructureNV is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2845,8 +2881,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) ==
"handle and wrapper have different size!" ); sizeof( VkDescriptorUpdateTemplate ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::value,
"DescriptorUpdateTemplate is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -2942,8 +2981,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkEvent m_event = {}; VkEvent m_event = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Event>::value,
"Event is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eEvent> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eEvent>
@ -3039,8 +3080,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkAccelerationStructureKHR m_accelerationStructureKHR = {}; VkAccelerationStructureKHR m_accelerationStructureKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) ==
"handle and wrapper have different size!" ); sizeof( VkAccelerationStructureKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::value,
"AccelerationStructureKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -4743,8 +4787,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkCommandBuffer m_commandBuffer = {}; VkCommandBuffer m_commandBuffer = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandBuffer>::value,
"CommandBuffer is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -4841,8 +4887,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDeviceMemory m_deviceMemory = {}; VkDeviceMemory m_deviceMemory = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceMemory>::value,
"DeviceMemory is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -4940,8 +4988,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkVideoSessionKHR m_videoSessionKHR = {}; VkVideoSessionKHR m_videoSessionKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::value,
"VideoSessionKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5032,8 +5082,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDeferredOperationKHR m_deferredOperationKHR = {}; VkDeferredOperationKHR m_deferredOperationKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::value,
"DeferredOperationKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5122,8 +5174,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkBufferView m_bufferView = {}; VkBufferView m_bufferView = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferView>::value,
"BufferView is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5220,8 +5274,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkCommandPool m_commandPool = {}; VkCommandPool m_commandPool = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandPool>::value,
"CommandPool is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5318,8 +5374,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkPipelineCache m_pipelineCache = {}; VkPipelineCache m_pipelineCache = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCache>::value,
"PipelineCache is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5416,8 +5474,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkCuFunctionNVX m_cuFunctionNVX = {}; VkCuFunctionNVX m_cuFunctionNVX = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::value,
"CuFunctionNVX is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5514,8 +5574,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkCuModuleNVX m_cuModuleNVX = {}; VkCuModuleNVX m_cuModuleNVX = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleNVX>::value,
"CuModuleNVX is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5612,8 +5674,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDescriptorPool m_descriptorPool = {}; VkDescriptorPool m_descriptorPool = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPool>::value,
"DescriptorPool is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5710,8 +5774,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDescriptorSetLayout m_descriptorSetLayout = {}; VkDescriptorSetLayout m_descriptorSetLayout = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::value,
"DescriptorSetLayout is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5808,8 +5874,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkFramebuffer m_framebuffer = {}; VkFramebuffer m_framebuffer = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Framebuffer>::value,
"Framebuffer is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5907,8 +5975,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) ==
"handle and wrapper have different size!" ); sizeof( VkIndirectCommandsLayoutNV ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::value,
"IndirectCommandsLayoutNV is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -5998,8 +6069,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkPrivateDataSlotEXT m_privateDataSlotEXT = {}; VkPrivateDataSlotEXT m_privateDataSlotEXT = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::value,
"PrivateDataSlotEXT is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -6088,8 +6161,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkRenderPass m_renderPass = {}; VkRenderPass m_renderPass = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPass>::value,
"RenderPass is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -6184,8 +6259,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkSampler m_sampler = {}; VkSampler m_sampler = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Sampler>::value,
"Sampler is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSampler> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSampler>
@ -6282,8 +6359,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkSamplerYcbcrConversion m_samplerYcbcrConversion = {}; VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) ==
"handle and wrapper have different size!" ); sizeof( VkSamplerYcbcrConversion ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::value,
"SamplerYcbcrConversion is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -6381,8 +6461,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkShaderModule m_shaderModule = {}; VkShaderModule m_shaderModule = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderModule>::value,
"ShaderModule is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -6479,8 +6561,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkValidationCacheEXT m_validationCacheEXT = {}; VkValidationCacheEXT m_validationCacheEXT = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::value,
"ValidationCacheEXT is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -6579,8 +6663,11 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkVideoSessionParametersKHR m_videoSessionParametersKHR = {}; VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) == sizeof( VkVideoSessionParametersKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) ==
"handle and wrapper have different size!" ); sizeof( VkVideoSessionParametersKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::value,
"VideoSessionParametersKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -6816,8 +6903,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkQueue m_queue = {}; VkQueue m_queue = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Queue>::value,
"Queue is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueue> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueue>
@ -11457,8 +11546,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDevice m_device = {}; VkDevice m_device = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Device>::value,
"Device is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDevice> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDevice>
@ -11554,8 +11645,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkDisplayModeKHR m_displayModeKHR = {}; VkDisplayModeKHR m_displayModeKHR = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::value,
"DisplayModeKHR is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -13060,8 +13153,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkPhysicalDevice m_physicalDevice = {}; VkPhysicalDevice m_physicalDevice = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevice>::value,
"PhysicalDevice is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( struct VULKAN_HPP_DEPRECATED(
@ -13842,8 +13937,10 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VkInstance m_instance = {}; VkInstance m_instance = {};
}; };
static_assert( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ),
"handle and wrapper have different size!" ); "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Instance>::value,
"Instance is not nothrow_move_constructible!" );
template <> template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eInstance> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eInstance>

7942
vulkan/vulkan_structs.hpp
View File

File diff suppressed because it is too large Load Diff