diff --git a/VkCppGenerator.cpp b/VkCppGenerator.cpp index 54274e6..8e47986 100644 --- a/VkCppGenerator.cpp +++ b/VkCppGenerator.cpp @@ -348,7 +348,7 @@ void writeTypeCommand( std::ofstream & ofs, DependencyData const& dependencyData void writeTypeCommandEnhanced(std::ofstream & ofs, std::string const& indentation, std::string const& className, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes); void writeTypeCommandEnhanced(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, size_t templateIndex, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, std::map const& vectorParameters); void writeTypeCommandEnhancedSingleStep(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, std::string const& returnType, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, size_t returnIndex, size_t templateIndex, std::map const& vectorParameters); -void writeTypeCommandEnhancedTwoStep(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, std::string const& returnType, size_t templateIndex, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, size_t returnIndex, std::map const& vectorParameters); +void writeTypeCommandEnhancedTwoStep(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, std::string const& returnType, size_t templateIndex, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, std::map const& vectorParameters); void writeTypeCommandEnhancedReplaceReturn(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, std::string const& returnType, size_t templateIndex, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, size_t returnIndex, std::map const& vectorParameters); void writeTypeCommandStandard(std::ofstream & ofs, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes); void writeTypeCommandComplexBody(std::ofstream & ofs, DependencyData const& dependencyData, CommandData const& commandData, std::map const& nameMap, std::map const& vectorParameters, std::set const& argIndices, size_t complexIndex, size_t returnIndex); @@ -463,11 +463,8 @@ std::string determineReturnType(CommandData const& commandData, size_t returnInd std::string returnType; if (returnIndex != ~0) { - if ((commandData.returnType == "Result") && (1 < commandData.successCodes.size())) - { - return("Result"); - } - else if (isVector) + assert((commandData.returnType == "void") || ((commandData.returnType == "Result") && (commandData.successCodes.size() == 1))); + if (isVector) { if (commandData.arguments[returnIndex].pureType == "void") { @@ -486,12 +483,14 @@ std::string determineReturnType(CommandData const& commandData, size_t returnInd returnType.pop_back(); } } - else if ((commandData.returnType == "Result") && (commandData.successCodes.size() < 2)) + else if ((commandData.returnType == "Result") && (commandData.successCodes.size() == 1)) { + // an original return of type "Result" with less just one successCode is change to void, errors throw an exception returnType = "void"; } else { + // the return type just stays the original return type returnType = commandData.returnType; } return std::move(returnType); @@ -517,17 +516,20 @@ std::string extractTag(std::string const& name) size_t findReturnIndex(CommandData const& commandData, std::map const& vectorParameters) { - for (size_t i = 0; i < commandData.arguments.size(); i++) + if ((commandData.returnType == "void") || ((commandData.returnType == "Result") && (commandData.successCodes.size() == 1))) { - if ((commandData.arguments[i].type.find('*') != std::string::npos) && (commandData.arguments[i].type.find("const") == std::string::npos) && !isVectorSizeParameter(vectorParameters, i)) + for (size_t i = 0; i < commandData.arguments.size(); i++) { -#if !defined(NDEBUG) - for (size_t j = i + 1; j < commandData.arguments.size(); j++) + if ((commandData.arguments[i].type.find('*') != std::string::npos) && (commandData.arguments[i].type.find("const") == std::string::npos) && !isVectorSizeParameter(vectorParameters, i)) { - assert((commandData.arguments[j].type.find('*') == std::string::npos) || (commandData.arguments[j].type.find("const") != std::string::npos)); - } +#if !defined(NDEBUG) + for (size_t j = i + 1; j < commandData.arguments.size(); j++) + { + assert((commandData.arguments[j].type.find('*') == std::string::npos) || (commandData.arguments[j].type.find("const") != std::string::npos)); + } #endif - return i; + return i; + } } } return ~0; @@ -1971,7 +1973,7 @@ void writeTypeCommandEnhanced(std::ofstream & ofs, std::string const& indentatio if (commandData.twoStep) { - writeTypeCommandEnhancedTwoStep(ofs, indentation, className, functionName, returnType, templateIndex, dependencyData, commandData, vkTypes, returnIndex, vectorParameters); + writeTypeCommandEnhancedTwoStep(ofs, indentation, className, functionName, returnType, templateIndex, dependencyData, commandData, vkTypes, vectorParameters); } else { @@ -2057,11 +2059,23 @@ void writeTypeCommandEnhancedSingleStep(std::ofstream & ofs, std::string const& } } -void writeTypeCommandEnhancedTwoStep(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, std::string const& returnType, size_t templateIndex, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, size_t returnIndex, std::map const& vectorParameters) +void writeTypeCommandEnhancedTwoStep(std::ofstream & ofs, std::string const& indentation, std::string const& className, std::string const& functionName, std::string const& returnType, size_t templateIndex, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes, std::map const& vectorParameters) { - assert(returnIndex != ~0); - std::map::const_iterator it = vectorParameters.find(returnIndex); - assert((it != vectorParameters.end()) && (it->second != ~0)); + std::map::const_iterator it; + for (it = vectorParameters.begin(); it != vectorParameters.end(); ++it) + { + if (commandData.arguments[it->first].type.find("const") == std::string::npos) + { +#if !defined(NDEBUG) + for (std::map::const_iterator jt = std::next(it); jt != vectorParameters.end(); ++jt) + { + assert(commandData.arguments[jt->first].type.find("const") != std::string::npos); + } +#endif + break; + } + } + assert(it != vectorParameters.end() && it->second != ~0); ofs << indentation << "{" << std::endl; if (commandData.successCodes.size() < 2) @@ -2073,13 +2087,13 @@ void writeTypeCommandEnhancedTwoStep(std::ofstream & ofs, std::string const& ind if (commandData.returnType == "Result") { ofs << "Result result = static_cast( "; - writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, returnIndex, "nullptr"); + writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, it->first, "nullptr"); ofs << " );" << std::endl; writeExceptionCheck(ofs, indentation, className, functionName, commandData.successCodes); } else { - writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, returnIndex, "nullptr"); + writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, it->first, "nullptr"); ofs << ";" << std::endl; } ofs << indentation << " " << reduceName(commandData.arguments[it->first].name) << ".resize( " << reduceName(commandData.arguments[it->second].name) << " );" << std::endl @@ -2087,18 +2101,18 @@ void writeTypeCommandEnhancedTwoStep(std::ofstream & ofs, std::string const& ind if (commandData.returnType == "Result") { ofs << "result = static_cast( "; - writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, returnIndex, reduceName(commandData.arguments[returnIndex].name) + ".data()"); + writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, it->first, reduceName(commandData.arguments[it->first].name) + ".data()"); ofs << " );" << std::endl; writeExceptionCheck(ofs, indentation, className, functionName, commandData.successCodes); } else { - writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, returnIndex, reduceName(commandData.arguments[returnIndex].name) + ".data()"); + writeCall(ofs, dependencyData.name, templateIndex, commandData, vkTypes, vectorParameters, it->first, reduceName(commandData.arguments[it->first].name) + ".data()"); ofs << ";" << std::endl; } if (commandData.successCodes.size() < 2) { - ofs << indentation << " return std::move( " << reduceName(commandData.arguments[returnIndex].name) << " );" << std::endl; + ofs << indentation << " return std::move( " << reduceName(commandData.arguments[it->first].name) << " );" << std::endl; } else if (commandData.returnType == "Result") { @@ -2217,8 +2231,7 @@ void writeTypeCommandStandard(std::ofstream & ofs, DependencyData const& depende ofs << " )"; } ofs << ";" << std::endl - << " }" << std::endl - << std::endl; + << " }" << std::endl; } void writeTypeCommandComplexBody(std::ofstream & ofs, DependencyData const& dependencyData, CommandData const& commandData, std::map const& nameMap, std::map const& vectorParameters, std::set const& argIndices, size_t complexIndex, size_t returnIndex) diff --git a/vulkan/vk_cpp.h b/vulkan/vk_cpp.h index 0c97def..a47e337 100644 --- a/vulkan/vk_cpp.h +++ b/vulkan/vk_cpp.h @@ -21162,7 +21162,7 @@ namespace vk } #ifdef VK_USE_PLATFORM_MIR_KHR - MirConnection getMirPresentationSupportKHR( uint32_t queueFamilyIndex ) const + Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection& connection ) const { return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection ); } @@ -21224,7 +21224,7 @@ namespace vk } #ifdef VK_USE_PLATFORM_WAYLAND_KHR - struct wl_display getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex ) const + Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display& display ) const { return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); } @@ -21238,14 +21238,14 @@ namespace vk #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_KHR - Display getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, VisualID visualID ) const + Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display& dpy, VisualID visualID ) const { return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); } #endif /*VK_USE_PLATFORM_XLIB_KHR*/ #ifdef VK_USE_PLATFORM_XCB_KHR - xcb_connection_t getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_visualid_t visual_id ) const + Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t& connection, xcb_visualid_t visual_id ) const { return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); } @@ -21639,7 +21639,6 @@ namespace vk { return static_cast( vkCreateInstance( reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pInstance ) ) ); } - #ifdef VKCPP_ENHANCED_MODE inline Instance createInstance( const InstanceCreateInfo& createInfo, const AllocationCallbacks& allocator ) { @@ -21658,78 +21657,65 @@ namespace vk vkDestroyInstance( static_cast( instance ), reinterpret_cast( pAllocator ) ); } - inline Result enumeratePhysicalDevices( Instance instance, uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) { return static_cast( vkEnumeratePhysicalDevices( static_cast( instance ), pPhysicalDeviceCount, reinterpret_cast( pPhysicalDevices ) ) ); } - inline PFN_vkVoidFunction getDeviceProcAddr( Device device, const char* pName ) { return vkGetDeviceProcAddr( static_cast( device ), pName ); } - inline PFN_vkVoidFunction getInstanceProcAddr( Instance instance, const char* pName ) { return vkGetInstanceProcAddr( static_cast( instance ), pName ); } - inline void getPhysicalDeviceProperties( PhysicalDevice physicalDevice, PhysicalDeviceProperties* pProperties ) { vkGetPhysicalDeviceProperties( static_cast( physicalDevice ), reinterpret_cast( pProperties ) ); } - inline void getPhysicalDeviceQueueFamilyProperties( PhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) { vkGetPhysicalDeviceQueueFamilyProperties( static_cast( physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); } - inline void getPhysicalDeviceMemoryProperties( PhysicalDevice physicalDevice, PhysicalDeviceMemoryProperties* pMemoryProperties ) { vkGetPhysicalDeviceMemoryProperties( static_cast( physicalDevice ), reinterpret_cast( pMemoryProperties ) ); } - inline void getPhysicalDeviceFeatures( PhysicalDevice physicalDevice, PhysicalDeviceFeatures* pFeatures ) { vkGetPhysicalDeviceFeatures( static_cast( physicalDevice ), reinterpret_cast( pFeatures ) ); } - inline void getPhysicalDeviceFormatProperties( PhysicalDevice physicalDevice, Format format, FormatProperties* pFormatProperties ) { vkGetPhysicalDeviceFormatProperties( static_cast( physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); } - inline Result getPhysicalDeviceImageFormatProperties( PhysicalDevice physicalDevice, Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties ) { return static_cast( vkGetPhysicalDeviceImageFormatProperties( static_cast( physicalDevice ), static_cast( format ), static_cast( type ), static_cast( tiling ), static_cast( usage ), static_cast( flags ), reinterpret_cast( pImageFormatProperties ) ) ); } - inline Result createDevice( PhysicalDevice physicalDevice, const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice ) { return static_cast( vkCreateDevice( static_cast( physicalDevice ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDevice ) ) ); } - inline void destroyDevice( Device device, const AllocationCallbacks* pAllocator ) { vkDestroyDevice( static_cast( device ), reinterpret_cast( pAllocator ) ); } - inline Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) { return static_cast( vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast( pProperties ) ) ); } - #ifdef VKCPP_ENHANCED_MODE inline Result enumerateInstanceLayerProperties( std::vector & properties ) { @@ -21753,7 +21739,6 @@ namespace vk { return static_cast( vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); } - #ifdef VKCPP_ENHANCED_MODE inline Result enumerateInstanceExtensionProperties( std::string const& layerName, std::vector & properties ) { @@ -21778,739 +21763,616 @@ namespace vk return static_cast( vkEnumerateDeviceLayerProperties( static_cast( physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); } - inline Result enumerateDeviceExtensionProperties( PhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) { return static_cast( vkEnumerateDeviceExtensionProperties( static_cast( physicalDevice ), pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); } - inline void getDeviceQueue( Device device, uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue ) { vkGetDeviceQueue( static_cast( device ), queueFamilyIndex, queueIndex, reinterpret_cast( pQueue ) ); } - inline Result queueSubmit( Queue queue, uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) { return static_cast( vkQueueSubmit( static_cast( queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); } - inline Result queueWaitIdle( Queue queue ) { return static_cast( vkQueueWaitIdle( static_cast( queue ) ) ); } - inline Result deviceWaitIdle( Device device ) { return static_cast( vkDeviceWaitIdle( static_cast( device ) ) ); } - inline Result allocateMemory( Device device, const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory ) { return static_cast( vkAllocateMemory( static_cast( device ), reinterpret_cast( pAllocateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMemory ) ) ); } - inline void freeMemory( Device device, DeviceMemory memory, const AllocationCallbacks* pAllocator ) { vkFreeMemory( static_cast( device ), static_cast( memory ), reinterpret_cast( pAllocator ) ); } - inline Result mapMemory( Device device, DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData ) { return static_cast( vkMapMemory( static_cast( device ), static_cast( memory ), offset, size, static_cast( flags ), ppData ) ); } - inline void unmapMemory( Device device, DeviceMemory memory ) { vkUnmapMemory( static_cast( device ), static_cast( memory ) ); } - inline Result flushMappedMemoryRanges( Device device, uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) { return static_cast( vkFlushMappedMemoryRanges( static_cast( device ), memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); } - inline Result invalidateMappedMemoryRanges( Device device, uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) { return static_cast( vkInvalidateMappedMemoryRanges( static_cast( device ), memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); } - inline void getDeviceMemoryCommitment( Device device, DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes ) { vkGetDeviceMemoryCommitment( static_cast( device ), static_cast( memory ), pCommittedMemoryInBytes ); } - inline void getBufferMemoryRequirements( Device device, Buffer buffer, MemoryRequirements* pMemoryRequirements ) { vkGetBufferMemoryRequirements( static_cast( device ), static_cast( buffer ), reinterpret_cast( pMemoryRequirements ) ); } - inline Result bindBufferMemory( Device device, Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) { return static_cast( vkBindBufferMemory( static_cast( device ), static_cast( buffer ), static_cast( memory ), memoryOffset ) ); } - inline void getImageMemoryRequirements( Device device, Image image, MemoryRequirements* pMemoryRequirements ) { vkGetImageMemoryRequirements( static_cast( device ), static_cast( image ), reinterpret_cast( pMemoryRequirements ) ); } - inline Result bindImageMemory( Device device, Image image, DeviceMemory memory, DeviceSize memoryOffset ) { return static_cast( vkBindImageMemory( static_cast( device ), static_cast( image ), static_cast( memory ), memoryOffset ) ); } - inline void getImageSparseMemoryRequirements( Device device, Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) { vkGetImageSparseMemoryRequirements( static_cast( device ), static_cast( image ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); } - inline void getPhysicalDeviceSparseImageFormatProperties( PhysicalDevice physicalDevice, Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) { vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( physicalDevice ), static_cast( format ), static_cast( type ), static_cast( samples ), static_cast( usage ), static_cast( tiling ), pPropertyCount, reinterpret_cast( pProperties ) ); } - inline Result queueBindSparse( Queue queue, uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence ) { return static_cast( vkQueueBindSparse( static_cast( queue ), bindInfoCount, reinterpret_cast( pBindInfo ), static_cast( fence ) ) ); } - inline Result createFence( Device device, const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) { return static_cast( vkCreateFence( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFence ) ) ); } - inline void destroyFence( Device device, Fence fence, const AllocationCallbacks* pAllocator ) { vkDestroyFence( static_cast( device ), static_cast( fence ), reinterpret_cast( pAllocator ) ); } - inline Result resetFences( Device device, uint32_t fenceCount, const Fence* pFences ) { return static_cast( vkResetFences( static_cast( device ), fenceCount, reinterpret_cast( pFences ) ) ); } - inline Result getFenceStatus( Device device, Fence fence ) { return static_cast( vkGetFenceStatus( static_cast( device ), static_cast( fence ) ) ); } - inline Result waitForFences( Device device, uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout ) { return static_cast( vkWaitForFences( static_cast( device ), fenceCount, reinterpret_cast( pFences ), waitAll, timeout ) ); } - inline Result createSemaphore( Device device, const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore ) { return static_cast( vkCreateSemaphore( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSemaphore ) ) ); } - inline void destroySemaphore( Device device, Semaphore semaphore, const AllocationCallbacks* pAllocator ) { vkDestroySemaphore( static_cast( device ), static_cast( semaphore ), reinterpret_cast( pAllocator ) ); } - inline Result createEvent( Device device, const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent ) { return static_cast( vkCreateEvent( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pEvent ) ) ); } - inline void destroyEvent( Device device, Event event, const AllocationCallbacks* pAllocator ) { vkDestroyEvent( static_cast( device ), static_cast( event ), reinterpret_cast( pAllocator ) ); } - inline Result getEventStatus( Device device, Event event ) { return static_cast( vkGetEventStatus( static_cast( device ), static_cast( event ) ) ); } - inline Result setEvent( Device device, Event event ) { return static_cast( vkSetEvent( static_cast( device ), static_cast( event ) ) ); } - inline Result resetEvent( Device device, Event event ) { return static_cast( vkResetEvent( static_cast( device ), static_cast( event ) ) ); } - inline Result createQueryPool( Device device, const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool ) { return static_cast( vkCreateQueryPool( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pQueryPool ) ) ); } - inline void destroyQueryPool( Device device, QueryPool queryPool, const AllocationCallbacks* pAllocator ) { vkDestroyQueryPool( static_cast( device ), static_cast( queryPool ), reinterpret_cast( pAllocator ) ); } - inline Result getQueryPoolResults( Device device, QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags ) { return static_cast( vkGetQueryPoolResults( static_cast( device ), static_cast( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast( flags ) ) ); } - inline Result createBuffer( Device device, const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer ) { return static_cast( vkCreateBuffer( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pBuffer ) ) ); } - inline void destroyBuffer( Device device, Buffer buffer, const AllocationCallbacks* pAllocator ) { vkDestroyBuffer( static_cast( device ), static_cast( buffer ), reinterpret_cast( pAllocator ) ); } - inline Result createBufferView( Device device, const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView ) { return static_cast( vkCreateBufferView( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pView ) ) ); } - inline void destroyBufferView( Device device, BufferView bufferView, const AllocationCallbacks* pAllocator ) { vkDestroyBufferView( static_cast( device ), static_cast( bufferView ), reinterpret_cast( pAllocator ) ); } - inline Result createImage( Device device, const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage ) { return static_cast( vkCreateImage( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pImage ) ) ); } - inline void destroyImage( Device device, Image image, const AllocationCallbacks* pAllocator ) { vkDestroyImage( static_cast( device ), static_cast( image ), reinterpret_cast( pAllocator ) ); } - inline void getImageSubresourceLayout( Device device, Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout ) { vkGetImageSubresourceLayout( static_cast( device ), static_cast( image ), reinterpret_cast( pSubresource ), reinterpret_cast( pLayout ) ); } - inline Result createImageView( Device device, const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView ) { return static_cast( vkCreateImageView( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pView ) ) ); } - inline void destroyImageView( Device device, ImageView imageView, const AllocationCallbacks* pAllocator ) { vkDestroyImageView( static_cast( device ), static_cast( imageView ), reinterpret_cast( pAllocator ) ); } - inline Result createShaderModule( Device device, const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule ) { return static_cast( vkCreateShaderModule( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pShaderModule ) ) ); } - inline void destroyShaderModule( Device device, ShaderModule shaderModule, const AllocationCallbacks* pAllocator ) { vkDestroyShaderModule( static_cast( device ), static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); } - inline Result createPipelineCache( Device device, const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache ) { return static_cast( vkCreatePipelineCache( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelineCache ) ) ); } - inline void destroyPipelineCache( Device device, PipelineCache pipelineCache, const AllocationCallbacks* pAllocator ) { vkDestroyPipelineCache( static_cast( device ), static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); } - inline Result getPipelineCacheData( Device device, PipelineCache pipelineCache, size_t* pDataSize, void* pData ) { return static_cast( vkGetPipelineCacheData( static_cast( device ), static_cast( pipelineCache ), pDataSize, pData ) ); } - inline Result mergePipelineCaches( Device device, PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) { return static_cast( vkMergePipelineCaches( static_cast( device ), static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); } - inline Result createGraphicsPipelines( Device device, PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) { return static_cast( vkCreateGraphicsPipelines( static_cast( device ), static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); } - inline Result createComputePipelines( Device device, PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) { return static_cast( vkCreateComputePipelines( static_cast( device ), static_cast( pipelineCache ), createInfoCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelines ) ) ); } - inline void destroyPipeline( Device device, Pipeline pipeline, const AllocationCallbacks* pAllocator ) { vkDestroyPipeline( static_cast( device ), static_cast( pipeline ), reinterpret_cast( pAllocator ) ); } - inline Result createPipelineLayout( Device device, const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout ) { return static_cast( vkCreatePipelineLayout( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pPipelineLayout ) ) ); } - inline void destroyPipelineLayout( Device device, PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator ) { vkDestroyPipelineLayout( static_cast( device ), static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); } - inline Result createSampler( Device device, const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler ) { return static_cast( vkCreateSampler( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSampler ) ) ); } - inline void destroySampler( Device device, Sampler sampler, const AllocationCallbacks* pAllocator ) { vkDestroySampler( static_cast( device ), static_cast( sampler ), reinterpret_cast( pAllocator ) ); } - inline Result createDescriptorSetLayout( Device device, const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout ) { return static_cast( vkCreateDescriptorSetLayout( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSetLayout ) ) ); } - inline void destroyDescriptorSetLayout( Device device, DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator ) { vkDestroyDescriptorSetLayout( static_cast( device ), static_cast( descriptorSetLayout ), reinterpret_cast( pAllocator ) ); } - inline Result createDescriptorPool( Device device, const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool ) { return static_cast( vkCreateDescriptorPool( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pDescriptorPool ) ) ); } - inline void destroyDescriptorPool( Device device, DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator ) { vkDestroyDescriptorPool( static_cast( device ), static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); } - inline Result resetDescriptorPool( Device device, DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) { return static_cast( vkResetDescriptorPool( static_cast( device ), static_cast( descriptorPool ), static_cast( flags ) ) ); } - inline Result allocateDescriptorSets( Device device, const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) { return static_cast( vkAllocateDescriptorSets( static_cast( device ), reinterpret_cast( pAllocateInfo ), reinterpret_cast( pDescriptorSets ) ) ); } - inline Result freeDescriptorSets( Device device, DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets ) { return static_cast( vkFreeDescriptorSets( static_cast( device ), static_cast( descriptorPool ), descriptorSetCount, reinterpret_cast( pDescriptorSets ) ) ); } - inline void updateDescriptorSets( Device device, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies ) { vkUpdateDescriptorSets( static_cast( device ), descriptorWriteCount, reinterpret_cast( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast( pDescriptorCopies ) ); } - inline Result createFramebuffer( Device device, const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer ) { return static_cast( vkCreateFramebuffer( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pFramebuffer ) ) ); } - inline void destroyFramebuffer( Device device, Framebuffer framebuffer, const AllocationCallbacks* pAllocator ) { vkDestroyFramebuffer( static_cast( device ), static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); } - inline Result createRenderPass( Device device, const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass ) { return static_cast( vkCreateRenderPass( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pRenderPass ) ) ); } - inline void destroyRenderPass( Device device, RenderPass renderPass, const AllocationCallbacks* pAllocator ) { vkDestroyRenderPass( static_cast( device ), static_cast( renderPass ), reinterpret_cast( pAllocator ) ); } - inline void getRenderAreaGranularity( Device device, RenderPass renderPass, Extent2D* pGranularity ) { vkGetRenderAreaGranularity( static_cast( device ), static_cast( renderPass ), reinterpret_cast( pGranularity ) ); } - inline Result createCommandPool( Device device, const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool ) { return static_cast( vkCreateCommandPool( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pCommandPool ) ) ); } - inline void destroyCommandPool( Device device, CommandPool commandPool, const AllocationCallbacks* pAllocator ) { vkDestroyCommandPool( static_cast( device ), static_cast( commandPool ), reinterpret_cast( pAllocator ) ); } - inline Result resetCommandPool( Device device, CommandPool commandPool, CommandPoolResetFlags flags ) { return static_cast( vkResetCommandPool( static_cast( device ), static_cast( commandPool ), static_cast( flags ) ) ); } - inline Result allocateCommandBuffers( Device device, const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) { return static_cast( vkAllocateCommandBuffers( static_cast( device ), reinterpret_cast( pAllocateInfo ), reinterpret_cast( pCommandBuffers ) ) ); } - inline void freeCommandBuffers( Device device, CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) { vkFreeCommandBuffers( static_cast( device ), static_cast( commandPool ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); } - inline Result beginCommandBuffer( CommandBuffer commandBuffer, const CommandBufferBeginInfo* pBeginInfo ) { return static_cast( vkBeginCommandBuffer( static_cast( commandBuffer ), reinterpret_cast( pBeginInfo ) ) ); } - inline Result endCommandBuffer( CommandBuffer commandBuffer ) { return static_cast( vkEndCommandBuffer( static_cast( commandBuffer ) ) ); } - inline Result resetCommandBuffer( CommandBuffer commandBuffer, CommandBufferResetFlags flags ) { return static_cast( vkResetCommandBuffer( static_cast( commandBuffer ), static_cast( flags ) ) ); } - inline void cmdBindPipeline( CommandBuffer commandBuffer, PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) { vkCmdBindPipeline( static_cast( commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); } - inline void cmdSetViewport( CommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports ) { vkCmdSetViewport( static_cast( commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewports ) ); } - inline void cmdSetScissor( CommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors ) { vkCmdSetScissor( static_cast( commandBuffer ), firstScissor, scissorCount, reinterpret_cast( pScissors ) ); } - inline void cmdSetLineWidth( CommandBuffer commandBuffer, float lineWidth ) { vkCmdSetLineWidth( static_cast( commandBuffer ), lineWidth ); } - inline void cmdSetDepthBias( CommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) { vkCmdSetDepthBias( static_cast( commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); } - inline void cmdSetBlendConstants( CommandBuffer commandBuffer, const float blendConstants[4] ) { vkCmdSetBlendConstants( static_cast( commandBuffer ), blendConstants ); } - inline void cmdSetDepthBounds( CommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) { vkCmdSetDepthBounds( static_cast( commandBuffer ), minDepthBounds, maxDepthBounds ); } - inline void cmdSetStencilCompareMask( CommandBuffer commandBuffer, StencilFaceFlags faceMask, uint32_t compareMask ) { vkCmdSetStencilCompareMask( static_cast( commandBuffer ), static_cast( faceMask ), compareMask ); } - inline void cmdSetStencilWriteMask( CommandBuffer commandBuffer, StencilFaceFlags faceMask, uint32_t writeMask ) { vkCmdSetStencilWriteMask( static_cast( commandBuffer ), static_cast( faceMask ), writeMask ); } - inline void cmdSetStencilReference( CommandBuffer commandBuffer, StencilFaceFlags faceMask, uint32_t reference ) { vkCmdSetStencilReference( static_cast( commandBuffer ), static_cast( faceMask ), reference ); } - inline void cmdBindDescriptorSets( CommandBuffer commandBuffer, PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) { vkCmdBindDescriptorSets( static_cast( commandBuffer ), static_cast( pipelineBindPoint ), static_cast( layout ), firstSet, descriptorSetCount, reinterpret_cast( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets ); } - inline void cmdBindIndexBuffer( CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset, IndexType indexType ) { vkCmdBindIndexBuffer( static_cast( commandBuffer ), static_cast( buffer ), offset, static_cast( indexType ) ); } - inline void cmdBindVertexBuffers( CommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets ) { vkCmdBindVertexBuffers( static_cast( commandBuffer ), firstBinding, bindingCount, reinterpret_cast( pBuffers ), pOffsets ); } - inline void cmdDraw( CommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) { vkCmdDraw( static_cast( commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); } - inline void cmdDrawIndexed( CommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) { vkCmdDrawIndexed( static_cast( commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); } - inline void cmdDrawIndirect( CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) { vkCmdDrawIndirect( static_cast( commandBuffer ), static_cast( buffer ), offset, drawCount, stride ); } - inline void cmdDrawIndexedIndirect( CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) { vkCmdDrawIndexedIndirect( static_cast( commandBuffer ), static_cast( buffer ), offset, drawCount, stride ); } - inline void cmdDispatch( CommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z ) { vkCmdDispatch( static_cast( commandBuffer ), x, y, z ); } - inline void cmdDispatchIndirect( CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset ) { vkCmdDispatchIndirect( static_cast( commandBuffer ), static_cast( buffer ), offset ); } - inline void cmdCopyBuffer( CommandBuffer commandBuffer, Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions ) { vkCmdCopyBuffer( static_cast( commandBuffer ), static_cast( srcBuffer ), static_cast( dstBuffer ), regionCount, reinterpret_cast( pRegions ) ); } - inline void cmdCopyImage( CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions ) { vkCmdCopyImage( static_cast( commandBuffer ), static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); } - inline void cmdBlitImage( CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter ) { vkCmdBlitImage( static_cast( commandBuffer ), static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ), static_cast( filter ) ); } - inline void cmdCopyBufferToImage( CommandBuffer commandBuffer, Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions ) { vkCmdCopyBufferToImage( static_cast( commandBuffer ), static_cast( srcBuffer ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); } - inline void cmdCopyImageToBuffer( CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions ) { vkCmdCopyImageToBuffer( static_cast( commandBuffer ), static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstBuffer ), regionCount, reinterpret_cast( pRegions ) ); } - inline void cmdUpdateBuffer( CommandBuffer commandBuffer, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const uint32_t* pData ) { vkCmdUpdateBuffer( static_cast( commandBuffer ), static_cast( dstBuffer ), dstOffset, dataSize, pData ); } - inline void cmdFillBuffer( CommandBuffer commandBuffer, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) { vkCmdFillBuffer( static_cast( commandBuffer ), static_cast( dstBuffer ), dstOffset, size, data ); } - inline void cmdClearColorImage( CommandBuffer commandBuffer, Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) { vkCmdClearColorImage( static_cast( commandBuffer ), static_cast( image ), static_cast( imageLayout ), reinterpret_cast( pColor ), rangeCount, reinterpret_cast( pRanges ) ); } - inline void cmdClearDepthStencilImage( CommandBuffer commandBuffer, Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) { vkCmdClearDepthStencilImage( static_cast( commandBuffer ), static_cast( image ), static_cast( imageLayout ), reinterpret_cast( pDepthStencil ), rangeCount, reinterpret_cast( pRanges ) ); } - inline void cmdClearAttachments( CommandBuffer commandBuffer, uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects ) { vkCmdClearAttachments( static_cast( commandBuffer ), attachmentCount, reinterpret_cast( pAttachments ), rectCount, reinterpret_cast( pRects ) ); } - inline void cmdResolveImage( CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions ) { vkCmdResolveImage( static_cast( commandBuffer ), static_cast( srcImage ), static_cast( srcImageLayout ), static_cast( dstImage ), static_cast( dstImageLayout ), regionCount, reinterpret_cast( pRegions ) ); } - inline void cmdSetEvent( CommandBuffer commandBuffer, Event event, PipelineStageFlags stageMask ) { vkCmdSetEvent( static_cast( commandBuffer ), static_cast( event ), static_cast( stageMask ) ); } - inline void cmdResetEvent( CommandBuffer commandBuffer, Event event, PipelineStageFlags stageMask ) { vkCmdResetEvent( static_cast( commandBuffer ), static_cast( event ), static_cast( stageMask ) ); } - inline void cmdWaitEvents( CommandBuffer commandBuffer, uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) { vkCmdWaitEvents( static_cast( commandBuffer ), eventCount, reinterpret_cast( pEvents ), static_cast( srcStageMask ), static_cast( dstStageMask ), memoryBarrierCount, reinterpret_cast( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); } - inline void cmdPipelineBarrier( CommandBuffer commandBuffer, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) { vkCmdPipelineBarrier( static_cast( commandBuffer ), static_cast( srcStageMask ), static_cast( dstStageMask ), static_cast( dependencyFlags ), memoryBarrierCount, reinterpret_cast( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); } - inline void cmdBeginQuery( CommandBuffer commandBuffer, QueryPool queryPool, uint32_t query, QueryControlFlags flags ) { vkCmdBeginQuery( static_cast( commandBuffer ), static_cast( queryPool ), query, static_cast( flags ) ); } - inline void cmdEndQuery( CommandBuffer commandBuffer, QueryPool queryPool, uint32_t query ) { vkCmdEndQuery( static_cast( commandBuffer ), static_cast( queryPool ), query ); } - inline void cmdResetQueryPool( CommandBuffer commandBuffer, QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) { vkCmdResetQueryPool( static_cast( commandBuffer ), static_cast( queryPool ), firstQuery, queryCount ); } - inline void cmdWriteTimestamp( CommandBuffer commandBuffer, PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) { vkCmdWriteTimestamp( static_cast( commandBuffer ), static_cast( pipelineStage ), static_cast( queryPool ), query ); } - inline void cmdCopyQueryPoolResults( CommandBuffer commandBuffer, QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) { vkCmdCopyQueryPoolResults( static_cast( commandBuffer ), static_cast( queryPool ), firstQuery, queryCount, static_cast( dstBuffer ), dstOffset, stride, static_cast( flags ) ); } - inline void cmdPushConstants( CommandBuffer commandBuffer, PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) { vkCmdPushConstants( static_cast( commandBuffer ), static_cast( layout ), static_cast( stageFlags ), offset, size, pValues ); } - inline void cmdBeginRenderPass( CommandBuffer commandBuffer, const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents ) { vkCmdBeginRenderPass( static_cast( commandBuffer ), reinterpret_cast( pRenderPassBegin ), static_cast( contents ) ); } - inline void cmdNextSubpass( CommandBuffer commandBuffer, SubpassContents contents ) { vkCmdNextSubpass( static_cast( commandBuffer ), static_cast( contents ) ); } - inline void cmdEndRenderPass( CommandBuffer commandBuffer ) { vkCmdEndRenderPass( static_cast( commandBuffer ) ); } - inline void cmdExecuteCommands( CommandBuffer commandBuffer, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) { vkCmdExecuteCommands( static_cast( commandBuffer ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); } - #ifdef VK_USE_PLATFORM_ANDROID_KHR inline Result createAndroidSurfaceKHR( Instance instance, const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) { return static_cast( vkCreateAndroidSurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ inline Result getPhysicalDeviceDisplayPropertiesKHR( PhysicalDevice physicalDevice, uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) @@ -22518,55 +22380,46 @@ namespace vk return static_cast( vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast( physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); } - inline Result getPhysicalDeviceDisplayPlanePropertiesKHR( PhysicalDevice physicalDevice, uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) { return static_cast( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast( physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); } - inline Result getDisplayPlaneSupportedDisplaysKHR( PhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) { return static_cast( vkGetDisplayPlaneSupportedDisplaysKHR( static_cast( physicalDevice ), planeIndex, pDisplayCount, reinterpret_cast( pDisplays ) ) ); } - inline Result getDisplayModePropertiesKHR( PhysicalDevice physicalDevice, DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) { return static_cast( vkGetDisplayModePropertiesKHR( static_cast( physicalDevice ), static_cast( display ), pPropertyCount, reinterpret_cast( pProperties ) ) ); } - inline Result createDisplayModeKHR( PhysicalDevice physicalDevice, DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) { return static_cast( vkCreateDisplayModeKHR( static_cast( physicalDevice ), static_cast( display ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pMode ) ) ); } - inline Result getDisplayPlaneCapabilitiesKHR( PhysicalDevice physicalDevice, DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities ) { return static_cast( vkGetDisplayPlaneCapabilitiesKHR( static_cast( physicalDevice ), static_cast( mode ), planeIndex, reinterpret_cast( pCapabilities ) ) ); } - inline Result createDisplayPlaneSurfaceKHR( Instance instance, const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) { return static_cast( vkCreateDisplayPlaneSurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - inline Result createSharedSwapchainsKHR( Device device, uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) { return static_cast( vkCreateSharedSwapchainsKHR( static_cast( device ), swapchainCount, reinterpret_cast( pCreateInfos ), reinterpret_cast( pAllocator ), reinterpret_cast( pSwapchains ) ) ); } - #ifdef VK_USE_PLATFORM_MIR_KHR inline Result createMirSurfaceKHR( Instance instance, const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) { return static_cast( vkCreateMirSurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - #endif /*VK_USE_PLATFORM_MIR_KHR*/ #ifdef VK_USE_PLATFORM_MIR_KHR @@ -22574,7 +22427,6 @@ namespace vk { return vkGetPhysicalDeviceMirPresentationSupportKHR( static_cast( physicalDevice ), queueFamilyIndex, connection ); } - #endif /*VK_USE_PLATFORM_MIR_KHR*/ inline void destroySurfaceKHR( Instance instance, SurfaceKHR surface, const AllocationCallbacks* pAllocator ) @@ -22582,67 +22434,56 @@ namespace vk vkDestroySurfaceKHR( static_cast( instance ), static_cast( surface ), reinterpret_cast( pAllocator ) ); } - inline Result getPhysicalDeviceSurfaceSupportKHR( PhysicalDevice physicalDevice, uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) { return static_cast( vkGetPhysicalDeviceSurfaceSupportKHR( static_cast( physicalDevice ), queueFamilyIndex, static_cast( surface ), pSupported ) ); } - inline Result getPhysicalDeviceSurfaceCapabilitiesKHR( PhysicalDevice physicalDevice, SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) { return static_cast( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast( physicalDevice ), static_cast( surface ), reinterpret_cast( pSurfaceCapabilities ) ) ); } - inline Result getPhysicalDeviceSurfaceFormatsKHR( PhysicalDevice physicalDevice, SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) { return static_cast( vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast( physicalDevice ), static_cast( surface ), pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); } - inline Result getPhysicalDeviceSurfacePresentModesKHR( PhysicalDevice physicalDevice, SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) { return static_cast( vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast( physicalDevice ), static_cast( surface ), pPresentModeCount, reinterpret_cast( pPresentModes ) ) ); } - inline Result createSwapchainKHR( Device device, const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain ) { return static_cast( vkCreateSwapchainKHR( static_cast( device ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSwapchain ) ) ); } - inline void destroySwapchainKHR( Device device, SwapchainKHR swapchain, const AllocationCallbacks* pAllocator ) { vkDestroySwapchainKHR( static_cast( device ), static_cast( swapchain ), reinterpret_cast( pAllocator ) ); } - inline Result getSwapchainImagesKHR( Device device, SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) { return static_cast( vkGetSwapchainImagesKHR( static_cast( device ), static_cast( swapchain ), pSwapchainImageCount, reinterpret_cast( pSwapchainImages ) ) ); } - inline Result acquireNextImageKHR( Device device, SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) { return static_cast( vkAcquireNextImageKHR( static_cast( device ), static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), pImageIndex ) ); } - inline Result queuePresentKHR( Queue queue, const PresentInfoKHR* pPresentInfo ) { return static_cast( vkQueuePresentKHR( static_cast( queue ), reinterpret_cast( pPresentInfo ) ) ); } - #ifdef VK_USE_PLATFORM_WAYLAND_KHR inline Result createWaylandSurfaceKHR( Instance instance, const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) { return static_cast( vkCreateWaylandSurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -22650,7 +22491,6 @@ namespace vk { return vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast( physicalDevice ), queueFamilyIndex, display ); } - #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -22658,7 +22498,6 @@ namespace vk { return static_cast( vkCreateWin32SurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -22666,7 +22505,6 @@ namespace vk { return vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast( physicalDevice ), queueFamilyIndex ); } - #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_KHR @@ -22674,7 +22512,6 @@ namespace vk { return static_cast( vkCreateXlibSurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - #endif /*VK_USE_PLATFORM_XLIB_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_KHR @@ -22682,7 +22519,6 @@ namespace vk { return vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast( physicalDevice ), queueFamilyIndex, dpy, visualID ); } - #endif /*VK_USE_PLATFORM_XLIB_KHR*/ #ifdef VK_USE_PLATFORM_XCB_KHR @@ -22690,7 +22526,6 @@ namespace vk { return static_cast( vkCreateXcbSurfaceKHR( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); } - #endif /*VK_USE_PLATFORM_XCB_KHR*/ #ifdef VK_USE_PLATFORM_XCB_KHR @@ -22698,7 +22533,6 @@ namespace vk { return vkGetPhysicalDeviceXcbPresentationSupportKHR( static_cast( physicalDevice ), queueFamilyIndex, connection, visual_id ); } - #endif /*VK_USE_PLATFORM_XCB_KHR*/ inline Result createDebugReportCallbackEXT( Instance instance, const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback ) @@ -22706,19 +22540,16 @@ namespace vk return static_cast( vkCreateDebugReportCallbackEXT( static_cast( instance ), reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pCallback ) ) ); } - inline void destroyDebugReportCallbackEXT( Instance instance, DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator ) { vkDestroyDebugReportCallbackEXT( static_cast( instance ), static_cast( callback ), reinterpret_cast( pAllocator ) ); } - inline void debugReportMessageEXT( Instance instance, DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) { vkDebugReportMessageEXT( static_cast( instance ), static_cast( flags ), static_cast( objectType ), object, location, messageCode, pLayerPrefix, pMessage ); } - inline std::string getString(FramebufferCreateFlagBits) { return std::string();