#undef MemoryBarrier
#endif
-static_assert( VK_HEADER_VERSION == 83 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 92 , "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
#endif
+
template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
+ template <typename P, typename T>
+ struct TypeList
+ {
+ using list = P;
+ using last = T;
+ };
+
+ template <typename List, typename X>
+ struct extendCheck
+ {
+ static const bool valid = isStructureChainValid<typename List::last, X>::value || extendCheck<typename List::list,X>::valid;
+ };
+
+ template <typename T, typename X>
+ struct extendCheck<TypeList<void,T>,X>
+ {
+ static const bool valid = isStructureChainValid<T, X>::value;
+ };
+
+ template <typename X>
+ struct extendCheck<void,X>
+ {
+ static const bool valid = true;
+ };
+
template <class Element>
class StructureChainElement
{
public:
StructureChain()
{
- link<StructureElements...>();
+ link<void, StructureElements...>();
}
StructureChain(StructureChain const &rhs)
{
- linkAndCopy<StructureElements...>(rhs);
+ linkAndCopy<void, StructureElements...>(rhs);
}
StructureChain(StructureElements const &... elems)
{
- linkAndCopyElements<StructureElements...>(elems...);
+ linkAndCopyElements<void, StructureElements...>(elems...);
}
StructureChain& operator=(StructureChain const &rhs)
{
- linkAndCopy<StructureElements...>(rhs);
+ linkAndCopy<void, StructureElements...>(rhs);
return *this;
}
template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);}
private:
- template<typename X>
+ template<typename List, typename X>
void link()
{
+ static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
}
- template<typename X, typename Y, typename ...Z>
+ template<typename List, typename X, typename Y, typename ...Z>
void link()
{
- static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
+ static_assert(extendCheck<List,X>::valid, "The structure chain is not valid!");
X& x = static_cast<X&>(*this);
Y& y = static_cast<Y&>(*this);
x.pNext = &y;
- link<Y, Z...>();
+ link<TypeList<List, X>, Y, Z...>();
}
- template<typename X>
+ template<typename List, typename X>
void linkAndCopy(StructureChain const &rhs)
{
+ static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
static_cast<X&>(*this) = static_cast<X const &>(rhs);
}
- template<typename X, typename Y, typename ...Z>
+ template<typename List, typename X, typename Y, typename ...Z>
void linkAndCopy(StructureChain const &rhs)
{
- static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
+ static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
X& x = static_cast<X&>(*this);
Y& y = static_cast<Y&>(*this);
x = static_cast<X const &>(rhs);
x.pNext = &y;
- linkAndCopy<Y, Z...>(rhs);
+ linkAndCopy<TypeList<List, X>, Y, Z...>(rhs);
}
- template<typename X>
+ template<typename List, typename X>
void linkAndCopyElements(X const &xelem)
{
+ static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
static_cast<X&>(*this) = xelem;
}
- template<typename X, typename Y, typename ...Z>
+ template<typename List, typename X, typename Y, typename ...Z>
void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem)
{
- static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
+ static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
X& x = static_cast<X&>(*this);
Y& y = static_cast<Y&>(*this);
x = xelem;
x.pNext = &y;
- linkAndCopyElements<Y, Z...>(yelem, zelem...);
+ linkAndCopyElements<TypeList<List, X>, Y, Z...>(yelem, zelem...);
}
};
eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
+ eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT
};
case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
+ case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT";
case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT";
default: return "invalid";
InvalidShaderNVError( char const * message )
: SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
};
+ class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
+ {
+ public:
+ InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
+ InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
+ : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
+ };
class FragmentationEXTError : public SystemError
{
public:
case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message );
case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message );
case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message );
+ case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError ( message );
case Result::eErrorFragmentationEXT: throw FragmentationEXTError ( message );
case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message );
default: throw SystemError( make_error_code( result ) );
{
return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo);
}
+ VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos ) const
+ {
+ return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos);
+ }
VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
{
return ::vkBindBufferMemory( device, buffer, memory, memoryOffset);
{
return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags);
}
+ void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
+ {
+ return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index);
+ }
void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const
{
return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents);
{
return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
}
+ void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
+ {
+ return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+ }
void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const
{
return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
{
return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline);
}
+ void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const
+ {
+ return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout);
+ }
+ void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes ) const
+ {
+ return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
+ }
void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets ) const
{
return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
{
return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
+ void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const
+ {
+ return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
+ }
void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const
{
return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
{
return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
+ void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode ) const
+ {
+ return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode);
+ }
void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const
{
return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
{
return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride);
}
+ void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride ) const
+ {
+ return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
+ }
void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
{
return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
{
return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
+ void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+ {
+ return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+ }
+ void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+ {
+ return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride);
+ }
+ void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const
+ {
+ return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask);
+ }
void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const
{
return ::vkCmdEndConditionalRenderingEXT( commandBuffer);
{
return ::vkCmdEndQuery( commandBuffer, queryPool, query);
}
+ void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const
+ {
+ return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index);
+ }
void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const
{
return ::vkCmdEndRenderPass( commandBuffer);
{
return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo);
}
+ void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
+ {
+ return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+ }
void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
{
return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers);
{
return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker);
}
+ void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders ) const
+ {
+ return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
+ }
void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
{
return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
{
return ::vkCmdSetEvent( commandBuffer, event, stageMask);
}
+ void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors ) const
+ {
+ return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
+ }
void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const
{
return ::vkCmdSetLineWidth( commandBuffer, lineWidth);
{
return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports);
}
+ void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes ) const
+ {
+ return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
+ }
void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const
{
return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings);
}
+ void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const
+ {
+ return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
+ }
void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const
{
return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData);
{
return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
+ void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const
+ {
+ return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
+ }
void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const
{
return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
{
return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query);
}
+ VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const
+ {
+ return ::vkCompileDeferredNV( device, pipeline, shader);
+ }
+ VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure ) const
+ {
+ return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure);
+ }
#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
{
{
return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage);
}
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+ {
+ return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface);
+ }
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView ) const
{
return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView);
return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
}
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- VkResult vkCreateMirSurfaceKHR( VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
- {
- return ::vkCreateMirSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
- }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const
{
return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable);
{
return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool);
}
+ VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+ {
+ return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
{
return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass);
{
return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
}
+ void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator ) const
+ {
+ return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator);
+ }
void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const
{
return ::vkDestroyBuffer( device, buffer, pAllocator);
{
return ::vkFreeMemory( device, memory, pAllocator);
}
+ VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData ) const
+ {
+ return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData);
+ }
+ void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const
+ {
+ return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements);
+ }
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const
{
{
return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
}
+ VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation ) const
+ {
+ return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
+ }
void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const
{
return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport);
return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
}
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties ) const
+ {
+ return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties);
+ }
void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements ) const
{
return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements);
{
return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings);
}
+ VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains ) const
+ {
+ return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains);
+ }
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties ) const
{
return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties);
{
return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties);
}
-#ifdef VK_USE_PLATFORM_MIR_KHR
- VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection ) const
- {
- return ::vkGetPhysicalDeviceMirPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection);
- }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const
{
return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties);
return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay);
}
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
+ VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const
+ {
+ return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData);
+ }
VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const
{
return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties);
class ObjectDestroy
{
public:
- ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &dispatch = Dispatch() )
+ ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
: m_owner( owner )
- , m_allocator( allocator )
+ , m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{}
OwnerType getOwner() const { return m_owner; }
- Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
protected:
template <typename T>
void destroy(T t)
{
- m_owner.destroy( t, m_allocator, *m_dispatch );
+ m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner;
- Optional<const AllocationCallbacks> m_allocator;
+ Optional<const AllocationCallbacks> m_allocationCallbacks;
Dispatch const* m_dispatch;
};
class ObjectDestroy<NoParent,Dispatch>
{
public:
- ObjectDestroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &dispatch = Dispatch() )
- : m_allocator( allocator )
+ ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+ : m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{}
- Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
protected:
template <typename T>
void destroy(T t)
{
- t.destroy( m_allocator, *m_dispatch );
+ t.destroy( m_allocationCallbacks, *m_dispatch );
}
private:
- Optional<const AllocationCallbacks> m_allocator;
+ Optional<const AllocationCallbacks> m_allocationCallbacks;
Dispatch const* m_dispatch;
};
class ObjectFree
{
public:
- ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &dispatch = Dispatch() )
+ ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
: m_owner( owner )
- , m_allocator( allocator )
+ , m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{}
OwnerType getOwner() const { return m_owner; }
- Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
protected:
template <typename T>
void destroy(T t)
{
- m_owner.free( t, m_allocator, *m_dispatch );
+ m_owner.free( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner;
- Optional<const AllocationCallbacks> m_allocator;
+ Optional<const AllocationCallbacks> m_allocationCallbacks;
Dispatch const* m_dispatch;
};
using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- enum class MirSurfaceCreateFlagBitsKHR
- {
- };
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
- using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
#ifdef VK_USE_PLATFORM_VI_NN
enum class ViSurfaceCreateFlagBitsNN
{
using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA
+ {
+ };
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA, VkImagePipeSurfaceCreateFlagsFUCHSIA>;
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
enum class CommandPoolTrimFlagBits
{
};
using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>;
+ enum class PipelineRasterizationStateStreamCreateFlagBitsEXT
+ {
+ };
+
+ using PipelineRasterizationStateStreamCreateFlagsEXT = Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT, VkPipelineRasterizationStateStreamCreateFlagsEXT>;
+
class DeviceMemory
{
public:
static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
+ class AccelerationStructureNV
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
+ : m_accelerationStructureNV(VK_NULL_HANDLE)
+ {}
+
+ VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t )
+ : m_accelerationStructureNV(VK_NULL_HANDLE)
+ {}
+
+ VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV )
+ : m_accelerationStructureNV( accelerationStructureNV )
+ {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+ AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV)
+ {
+ m_accelerationStructureNV = accelerationStructureNV;
+ return *this;
+ }
+#endif
+
+ AccelerationStructureNV & operator=( std::nullptr_t )
+ {
+ m_accelerationStructureNV = VK_NULL_HANDLE;
+ return *this;
+ }
+
+ bool operator==( AccelerationStructureNV const & rhs ) const
+ {
+ return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
+ }
+
+ bool operator!=(AccelerationStructureNV const & rhs ) const
+ {
+ return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
+ }
+
+ bool operator<(AccelerationStructureNV const & rhs ) const
+ {
+ return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
+ }
+
+
+
+ VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const
+ {
+ return m_accelerationStructureNV;
+ }
+
+ explicit operator bool() const
+ {
+ return m_accelerationStructureNV != VK_NULL_HANDLE;
+ }
+
+ bool operator!() const
+ {
+ return m_accelerationStructureNV == VK_NULL_HANDLE;
+ }
+
+ private:
+ VkAccelerationStructureNV m_accelerationStructureNV;
+ };
+
+ static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
+
class DisplayKHR
{
public:
return *this;
}
- operator const VkOffset2D&() const
+ operator VkOffset2D const&() const
{
return *reinterpret_cast<const VkOffset2D*>(this);
}
+ operator VkOffset2D &()
+ {
+ return *reinterpret_cast<VkOffset2D*>(this);
+ }
+
bool operator==( Offset2D const& rhs ) const
{
return ( x == rhs.x )
return *this;
}
- operator const VkOffset3D&() const
+ operator VkOffset3D const&() const
{
return *reinterpret_cast<const VkOffset3D*>(this);
}
+ operator VkOffset3D &()
+ {
+ return *reinterpret_cast<VkOffset3D*>(this);
+ }
+
bool operator==( Offset3D const& rhs ) const
{
return ( x == rhs.x )
return *this;
}
- operator const VkExtent2D&() const
+ operator VkExtent2D const&() const
{
return *reinterpret_cast<const VkExtent2D*>(this);
}
+ operator VkExtent2D &()
+ {
+ return *reinterpret_cast<VkExtent2D*>(this);
+ }
+
bool operator==( Extent2D const& rhs ) const
{
return ( width == rhs.width )
return *this;
}
- operator const VkExtent3D&() const
+ operator VkExtent3D const&() const
{
return *reinterpret_cast<const VkExtent3D*>(this);
}
+ operator VkExtent3D &()
+ {
+ return *reinterpret_cast<VkExtent3D*>(this);
+ }
+
bool operator==( Extent3D const& rhs ) const
{
return ( width == rhs.width )
return *this;
}
- operator const VkViewport&() const
+ operator VkViewport const&() const
{
return *reinterpret_cast<const VkViewport*>(this);
}
+ operator VkViewport &()
+ {
+ return *reinterpret_cast<VkViewport*>(this);
+ }
+
bool operator==( Viewport const& rhs ) const
{
return ( x == rhs.x )
return *this;
}
- operator const VkRect2D&() const
+ operator VkRect2D const&() const
{
return *reinterpret_cast<const VkRect2D*>(this);
}
+ operator VkRect2D &()
+ {
+ return *reinterpret_cast<VkRect2D*>(this);
+ }
+
bool operator==( Rect2D const& rhs ) const
{
return ( offset == rhs.offset )
return *this;
}
- operator const VkClearRect&() const
+ operator VkClearRect const&() const
{
return *reinterpret_cast<const VkClearRect*>(this);
}
+ operator VkClearRect &()
+ {
+ return *reinterpret_cast<VkClearRect*>(this);
+ }
+
bool operator==( ClearRect const& rhs ) const
{
return ( rect == rhs.rect )
struct ExtensionProperties
{
- operator const VkExtensionProperties&() const
+ operator VkExtensionProperties const&() const
{
return *reinterpret_cast<const VkExtensionProperties*>(this);
}
+ operator VkExtensionProperties &()
+ {
+ return *reinterpret_cast<VkExtensionProperties*>(this);
+ }
+
bool operator==( ExtensionProperties const& rhs ) const
{
return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
struct LayerProperties
{
- operator const VkLayerProperties&() const
+ operator VkLayerProperties const&() const
{
return *reinterpret_cast<const VkLayerProperties*>(this);
}
+ operator VkLayerProperties &()
+ {
+ return *reinterpret_cast<VkLayerProperties*>(this);
+ }
+
bool operator==( LayerProperties const& rhs ) const
{
return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
return *this;
}
- operator const VkAllocationCallbacks&() const
+ operator VkAllocationCallbacks const&() const
{
return *reinterpret_cast<const VkAllocationCallbacks*>(this);
}
+ operator VkAllocationCallbacks &()
+ {
+ return *reinterpret_cast<VkAllocationCallbacks*>(this);
+ }
+
bool operator==( AllocationCallbacks const& rhs ) const
{
return ( pUserData == rhs.pUserData )
struct MemoryRequirements
{
- operator const VkMemoryRequirements&() const
+ operator VkMemoryRequirements const&() const
{
return *reinterpret_cast<const VkMemoryRequirements*>(this);
}
+ operator VkMemoryRequirements &()
+ {
+ return *reinterpret_cast<VkMemoryRequirements*>(this);
+ }
+
bool operator==( MemoryRequirements const& rhs ) const
{
return ( size == rhs.size )
return *this;
}
- operator const VkDescriptorBufferInfo&() const
+ operator VkDescriptorBufferInfo const&() const
{
return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
}
+ operator VkDescriptorBufferInfo &()
+ {
+ return *reinterpret_cast<VkDescriptorBufferInfo*>(this);
+ }
+
bool operator==( DescriptorBufferInfo const& rhs ) const
{
return ( buffer == rhs.buffer )
struct SubresourceLayout
{
- operator const VkSubresourceLayout&() const
+ operator VkSubresourceLayout const&() const
{
return *reinterpret_cast<const VkSubresourceLayout*>(this);
}
+ operator VkSubresourceLayout &()
+ {
+ return *reinterpret_cast<VkSubresourceLayout*>(this);
+ }
+
bool operator==( SubresourceLayout const& rhs ) const
{
return ( offset == rhs.offset )
return *this;
}
- operator const VkBufferCopy&() const
+ operator VkBufferCopy const&() const
{
return *reinterpret_cast<const VkBufferCopy*>(this);
}
+ operator VkBufferCopy &()
+ {
+ return *reinterpret_cast<VkBufferCopy*>(this);
+ }
+
bool operator==( BufferCopy const& rhs ) const
{
return ( srcOffset == rhs.srcOffset )
return *this;
}
- operator const VkSpecializationMapEntry&() const
+ operator VkSpecializationMapEntry const&() const
{
return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
}
+ operator VkSpecializationMapEntry &()
+ {
+ return *reinterpret_cast<VkSpecializationMapEntry*>(this);
+ }
+
bool operator==( SpecializationMapEntry const& rhs ) const
{
return ( constantID == rhs.constantID )
return *this;
}
- operator const VkSpecializationInfo&() const
+ operator VkSpecializationInfo const&() const
{
return *reinterpret_cast<const VkSpecializationInfo*>(this);
}
+ operator VkSpecializationInfo &()
+ {
+ return *reinterpret_cast<VkSpecializationInfo*>(this);
+ }
+
bool operator==( SpecializationInfo const& rhs ) const
{
return ( mapEntryCount == rhs.mapEntryCount )
return *this;
}
- operator VkClearColorValue const& () const
+ operator VkClearColorValue const&() const
{
return *reinterpret_cast<const VkClearColorValue*>(this);
}
+ operator VkClearColorValue &()
+ {
+ return *reinterpret_cast<VkClearColorValue*>(this);
+ }
+
float float32[4];
int32_t int32[4];
uint32_t uint32[4];
return *this;
}
- operator const VkClearDepthStencilValue&() const
+ operator VkClearDepthStencilValue const&() const
{
return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
}
+ operator VkClearDepthStencilValue &()
+ {
+ return *reinterpret_cast<VkClearDepthStencilValue*>(this);
+ }
+
bool operator==( ClearDepthStencilValue const& rhs ) const
{
return ( depth == rhs.depth )
return *this;
}
- operator VkClearValue const& () const
+ operator VkClearValue const&() const
{
return *reinterpret_cast<const VkClearValue*>(this);
}
+ operator VkClearValue &()
+ {
+ return *reinterpret_cast<VkClearValue*>(this);
+ }
+
#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
ClearColorValue color;
ClearDepthStencilValue depthStencil;
return *this;
}
- operator const VkPhysicalDeviceFeatures&() const
+ operator VkPhysicalDeviceFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
}
+ operator VkPhysicalDeviceFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceFeatures*>(this);
+ }
+
bool operator==( PhysicalDeviceFeatures const& rhs ) const
{
return ( robustBufferAccess == rhs.robustBufferAccess )
struct PhysicalDeviceSparseProperties
{
- operator const VkPhysicalDeviceSparseProperties&() const
+ operator VkPhysicalDeviceSparseProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
}
+ operator VkPhysicalDeviceSparseProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this);
+ }
+
bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
{
return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
return *this;
}
- operator const VkDrawIndirectCommand&() const
+ operator VkDrawIndirectCommand const&() const
{
return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
}
+ operator VkDrawIndirectCommand &()
+ {
+ return *reinterpret_cast<VkDrawIndirectCommand*>(this);
+ }
+
bool operator==( DrawIndirectCommand const& rhs ) const
{
return ( vertexCount == rhs.vertexCount )
return *this;
}
- operator const VkDrawIndexedIndirectCommand&() const
+ operator VkDrawIndexedIndirectCommand const&() const
{
return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
}
+ operator VkDrawIndexedIndirectCommand &()
+ {
+ return *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this);
+ }
+
bool operator==( DrawIndexedIndirectCommand const& rhs ) const
{
return ( indexCount == rhs.indexCount )
return *this;
}
- operator const VkDispatchIndirectCommand&() const
+ operator VkDispatchIndirectCommand const&() const
{
return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
}
+ operator VkDispatchIndirectCommand &()
+ {
+ return *reinterpret_cast<VkDispatchIndirectCommand*>(this);
+ }
+
bool operator==( DispatchIndirectCommand const& rhs ) const
{
return ( x == rhs.x )
struct DisplayPlanePropertiesKHR
{
- operator const VkDisplayPlanePropertiesKHR&() const
+ operator VkDisplayPlanePropertiesKHR const&() const
{
return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
}
+ operator VkDisplayPlanePropertiesKHR &()
+ {
+ return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this);
+ }
+
bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
{
return ( currentDisplay == rhs.currentDisplay )
return *this;
}
- operator const VkDisplayModeParametersKHR&() const
+ operator VkDisplayModeParametersKHR const&() const
{
return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
}
+ operator VkDisplayModeParametersKHR &()
+ {
+ return *reinterpret_cast<VkDisplayModeParametersKHR*>(this);
+ }
+
bool operator==( DisplayModeParametersKHR const& rhs ) const
{
return ( visibleRegion == rhs.visibleRegion )
struct DisplayModePropertiesKHR
{
- operator const VkDisplayModePropertiesKHR&() const
+ operator VkDisplayModePropertiesKHR const&() const
{
return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
}
+ operator VkDisplayModePropertiesKHR &()
+ {
+ return *reinterpret_cast<VkDisplayModePropertiesKHR*>(this);
+ }
+
bool operator==( DisplayModePropertiesKHR const& rhs ) const
{
return ( displayMode == rhs.displayMode )
};
static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
+ struct ConformanceVersionKHR
+ {
+ ConformanceVersionKHR( uint8_t major_ = 0,
+ uint8_t minor_ = 0,
+ uint8_t subminor_ = 0,
+ uint8_t patch_ = 0 )
+ : major( major_ )
+ , minor( minor_ )
+ , subminor( subminor_ )
+ , patch( patch_ )
+ {
+ }
+
+ ConformanceVersionKHR( VkConformanceVersionKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
+ }
+
+ ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
+ return *this;
+ }
+ ConformanceVersionKHR& setMajor( uint8_t major_ )
+ {
+ major = major_;
+ return *this;
+ }
+
+ ConformanceVersionKHR& setMinor( uint8_t minor_ )
+ {
+ minor = minor_;
+ return *this;
+ }
+
+ ConformanceVersionKHR& setSubminor( uint8_t subminor_ )
+ {
+ subminor = subminor_;
+ return *this;
+ }
+
+ ConformanceVersionKHR& setPatch( uint8_t patch_ )
+ {
+ patch = patch_;
+ return *this;
+ }
+
+ operator VkConformanceVersionKHR const&() const
+ {
+ return *reinterpret_cast<const VkConformanceVersionKHR*>(this);
+ }
+
+ operator VkConformanceVersionKHR &()
+ {
+ return *reinterpret_cast<VkConformanceVersionKHR*>(this);
+ }
+
+ bool operator==( ConformanceVersionKHR const& rhs ) const
+ {
+ return ( major == rhs.major )
+ && ( minor == rhs.minor )
+ && ( subminor == rhs.subminor )
+ && ( patch == rhs.patch );
+ }
+
+ bool operator!=( ConformanceVersionKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint8_t major;
+ uint8_t minor;
+ uint8_t subminor;
+ uint8_t patch;
+ };
+ static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
+
struct RectLayerKHR
{
RectLayerKHR( Offset2D offset_ = Offset2D(),
return *this;
}
- operator const VkRectLayerKHR&() const
+ operator VkRectLayerKHR const&() const
{
return *reinterpret_cast<const VkRectLayerKHR*>(this);
}
+ operator VkRectLayerKHR &()
+ {
+ return *reinterpret_cast<VkRectLayerKHR*>(this);
+ }
+
bool operator==( RectLayerKHR const& rhs ) const
{
return ( offset == rhs.offset )
return *this;
}
- operator const VkPresentRegionKHR&() const
+ operator VkPresentRegionKHR const&() const
{
return *reinterpret_cast<const VkPresentRegionKHR*>(this);
}
+ operator VkPresentRegionKHR &()
+ {
+ return *reinterpret_cast<VkPresentRegionKHR*>(this);
+ }
+
bool operator==( PresentRegionKHR const& rhs ) const
{
return ( rectangleCount == rhs.rectangleCount )
return *this;
}
- operator const VkXYColorEXT&() const
+ operator VkXYColorEXT const&() const
{
return *reinterpret_cast<const VkXYColorEXT*>(this);
}
+ operator VkXYColorEXT &()
+ {
+ return *reinterpret_cast<VkXYColorEXT*>(this);
+ }
+
bool operator==( XYColorEXT const& rhs ) const
{
return ( x == rhs.x )
struct RefreshCycleDurationGOOGLE
{
- operator const VkRefreshCycleDurationGOOGLE&() const
+ operator VkRefreshCycleDurationGOOGLE const&() const
{
return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this);
}
+ operator VkRefreshCycleDurationGOOGLE &()
+ {
+ return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this);
+ }
+
bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const
{
return ( refreshDuration == rhs.refreshDuration );
struct PastPresentationTimingGOOGLE
{
- operator const VkPastPresentationTimingGOOGLE&() const
+ operator VkPastPresentationTimingGOOGLE const&() const
{
return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this);
}
+ operator VkPastPresentationTimingGOOGLE &()
+ {
+ return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this);
+ }
+
bool operator==( PastPresentationTimingGOOGLE const& rhs ) const
{
return ( presentID == rhs.presentID )
return *this;
}
- operator const VkPresentTimeGOOGLE&() const
+ operator VkPresentTimeGOOGLE const&() const
{
return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this);
}
+ operator VkPresentTimeGOOGLE &()
+ {
+ return *reinterpret_cast<VkPresentTimeGOOGLE*>(this);
+ }
+
bool operator==( PresentTimeGOOGLE const& rhs ) const
{
return ( presentID == rhs.presentID )
return *this;
}
- operator const VkViewportWScalingNV&() const
+ operator VkViewportWScalingNV const&() const
{
return *reinterpret_cast<const VkViewportWScalingNV*>(this);
}
+ operator VkViewportWScalingNV &()
+ {
+ return *reinterpret_cast<VkViewportWScalingNV*>(this);
+ }
+
bool operator==( ViewportWScalingNV const& rhs ) const
{
return ( xcoeff == rhs.xcoeff )
return *this;
}
- operator const VkSampleLocationEXT&() const
+ operator VkSampleLocationEXT const&() const
{
return *reinterpret_cast<const VkSampleLocationEXT*>(this);
}
+ operator VkSampleLocationEXT &()
+ {
+ return *reinterpret_cast<VkSampleLocationEXT*>(this);
+ }
+
bool operator==( SampleLocationEXT const& rhs ) const
{
return ( x == rhs.x )
struct ShaderResourceUsageAMD
{
- operator const VkShaderResourceUsageAMD&() const
+ operator VkShaderResourceUsageAMD const&() const
{
return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
}
+ operator VkShaderResourceUsageAMD &()
+ {
+ return *reinterpret_cast<VkShaderResourceUsageAMD*>(this);
+ }
+
bool operator==( ShaderResourceUsageAMD const& rhs ) const
{
return ( numUsedVgprs == rhs.numUsedVgprs )
return *this;
}
- operator const VkVertexInputBindingDivisorDescriptionEXT&() const
+ operator VkVertexInputBindingDivisorDescriptionEXT const&() const
{
return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>(this);
}
+ operator VkVertexInputBindingDivisorDescriptionEXT &()
+ {
+ return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this);
+ }
+
bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
{
return ( binding == rhs.binding )
};
static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
+ struct CoarseSampleLocationNV
+ {
+ CoarseSampleLocationNV( uint32_t pixelX_ = 0,
+ uint32_t pixelY_ = 0,
+ uint32_t sample_ = 0 )
+ : pixelX( pixelX_ )
+ , pixelY( pixelY_ )
+ , sample( sample_ )
+ {
+ }
+
+ CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+ }
+
+ CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+ return *this;
+ }
+ CoarseSampleLocationNV& setPixelX( uint32_t pixelX_ )
+ {
+ pixelX = pixelX_;
+ return *this;
+ }
+
+ CoarseSampleLocationNV& setPixelY( uint32_t pixelY_ )
+ {
+ pixelY = pixelY_;
+ return *this;
+ }
+
+ CoarseSampleLocationNV& setSample( uint32_t sample_ )
+ {
+ sample = sample_;
+ return *this;
+ }
+
+ operator VkCoarseSampleLocationNV const&() const
+ {
+ return *reinterpret_cast<const VkCoarseSampleLocationNV*>(this);
+ }
+
+ operator VkCoarseSampleLocationNV &()
+ {
+ return *reinterpret_cast<VkCoarseSampleLocationNV*>(this);
+ }
+
+ bool operator==( CoarseSampleLocationNV const& rhs ) const
+ {
+ return ( pixelX == rhs.pixelX )
+ && ( pixelY == rhs.pixelY )
+ && ( sample == rhs.sample );
+ }
+
+ bool operator!=( CoarseSampleLocationNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t pixelX;
+ uint32_t pixelY;
+ uint32_t sample;
+ };
+ static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
+
+ struct DrawMeshTasksIndirectCommandNV
+ {
+ DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
+ uint32_t firstTask_ = 0 )
+ : taskCount( taskCount_ )
+ , firstTask( firstTask_ )
+ {
+ }
+
+ DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+ }
+
+ DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+ return *this;
+ }
+ DrawMeshTasksIndirectCommandNV& setTaskCount( uint32_t taskCount_ )
+ {
+ taskCount = taskCount_;
+ return *this;
+ }
+
+ DrawMeshTasksIndirectCommandNV& setFirstTask( uint32_t firstTask_ )
+ {
+ firstTask = firstTask_;
+ return *this;
+ }
+
+ operator VkDrawMeshTasksIndirectCommandNV const&() const
+ {
+ return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>(this);
+ }
+
+ operator VkDrawMeshTasksIndirectCommandNV &()
+ {
+ return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this);
+ }
+
+ bool operator==( DrawMeshTasksIndirectCommandNV const& rhs ) const
+ {
+ return ( taskCount == rhs.taskCount )
+ && ( firstTask == rhs.firstTask );
+ }
+
+ bool operator!=( DrawMeshTasksIndirectCommandNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t taskCount;
+ uint32_t firstTask;
+ };
+ static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
+
enum class ImageLayout
{
eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
- eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
+ eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
+ eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV
};
struct DescriptorImageInfo
return *this;
}
- operator const VkDescriptorImageInfo&() const
+ operator VkDescriptorImageInfo const&() const
{
return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
}
+ operator VkDescriptorImageInfo &()
+ {
+ return *reinterpret_cast<VkDescriptorImageInfo*>(this);
+ }
+
bool operator==( DescriptorImageInfo const& rhs ) const
{
return ( sampler == rhs.sampler )
return *this;
}
- operator const VkAttachmentReference&() const
+ operator VkAttachmentReference const&() const
{
return *reinterpret_cast<const VkAttachmentReference*>(this);
}
+ operator VkAttachmentReference &()
+ {
+ return *reinterpret_cast<VkAttachmentReference*>(this);
+ }
+
bool operator==( AttachmentReference const& rhs ) const
{
return ( attachment == rhs.attachment )
enum class ImageTiling
{
eOptimal = VK_IMAGE_TILING_OPTIMAL,
- eLinear = VK_IMAGE_TILING_LINEAR
+ eLinear = VK_IMAGE_TILING_LINEAR,
+ eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
};
enum class ImageViewType
return *this;
}
- operator const VkComponentMapping&() const
+ operator VkComponentMapping const&() const
{
return *reinterpret_cast<const VkComponentMapping*>(this);
}
+ operator VkComponentMapping &()
+ {
+ return *reinterpret_cast<VkComponentMapping*>(this);
+ }
+
bool operator==( ComponentMapping const& rhs ) const
{
return ( r == rhs.r )
eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
- eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
+ eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+ eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
+ eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
};
struct DescriptorPoolSize
return *this;
}
- operator const VkDescriptorPoolSize&() const
+ operator VkDescriptorPoolSize const&() const
{
return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
}
+ operator VkDescriptorPoolSize &()
+ {
+ return *reinterpret_cast<VkDescriptorPoolSize*>(this);
+ }
+
bool operator==( DescriptorPoolSize const& rhs ) const
{
return ( type == rhs.type )
return *this;
}
- operator const VkDescriptorUpdateTemplateEntry&() const
+ operator VkDescriptorUpdateTemplateEntry const&() const
{
return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>(this);
}
+ operator VkDescriptorUpdateTemplateEntry &()
+ {
+ return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this);
+ }
+
bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const
{
return ( dstBinding == rhs.dstBinding )
{
eOcclusion = VK_QUERY_TYPE_OCCLUSION,
ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
- eTimestamp = VK_QUERY_TYPE_TIMESTAMP
+ eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
+ eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
+ eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV
};
enum class BorderColor
enum class PipelineBindPoint
{
eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
- eCompute = VK_PIPELINE_BIND_POINT_COMPUTE
+ eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
+ eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
};
enum class PipelineCacheHeaderVersion
enum class IndexType
{
eUint16 = VK_INDEX_TYPE_UINT16,
- eUint32 = VK_INDEX_TYPE_UINT32
+ eUint32 = VK_INDEX_TYPE_UINT32,
+ eNoneNV = VK_INDEX_TYPE_NONE_NV
};
enum class Filter
return *this;
}
- operator const VkStencilOpState&() const
+ operator VkStencilOpState const&() const
{
return *reinterpret_cast<const VkStencilOpState*>(this);
}
+ operator VkStencilOpState &()
+ {
+ return *reinterpret_cast<VkStencilOpState*>(this);
+ }
+
bool operator==( StencilOpState const& rhs ) const
{
return ( failOp == rhs.failOp )
return *this;
}
- operator const VkVertexInputBindingDescription&() const
+ operator VkVertexInputBindingDescription const&() const
{
return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
}
+ operator VkVertexInputBindingDescription &()
+ {
+ return *reinterpret_cast<VkVertexInputBindingDescription*>(this);
+ }
+
bool operator==( VertexInputBindingDescription const& rhs ) const
{
return ( binding == rhs.binding )
return *this;
}
- operator const VkVertexInputAttributeDescription&() const
+ operator VkVertexInputAttributeDescription const&() const
{
return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
}
+ operator VkVertexInputAttributeDescription &()
+ {
+ return *reinterpret_cast<VkVertexInputAttributeDescription*>(this);
+ }
+
bool operator==( VertexInputAttributeDescription const& rhs ) const
{
return ( location == rhs.location )
eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
- eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR,
eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
+ ePhysicalDeviceTransformFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
+ ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
+ ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
+ ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
+ eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
+ ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT,
eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT,
+ ePhysicalDeviceInlineUniformBlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT,
+ ePhysicalDeviceInlineUniformBlockPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT,
+ eWriteDescriptorSetInlineUniformBlockEXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT,
+ eDescriptorPoolInlineUniformBlockCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT,
eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
+ eDrmFormatModifierPropertiesListEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
+ eDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
+ ePhysicalDeviceImageDrmFormatModifierInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
+ eImageDrmFormatModifierListCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
+ eImageDrmFormatModifierExplicitCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
+ eImageDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT,
eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT,
eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT,
eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT,
+ ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
+ ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
+ ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
+ ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
+ eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,
+ eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
+ eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV,
+ eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
+ eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV,
+ eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
+ eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
+ eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
+ ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
+ eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
+ eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
+ ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
+ ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR,
eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
+ ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
+ eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT,
ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
+ eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
+ ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
+ ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
+ ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
+ ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
+ ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
+ ePhysicalDeviceFragmentShaderBarycentricFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
+ ePhysicalDeviceShaderImageFootprintFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
+ ePipelineViewportExclusiveScissorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
+ ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV,
- eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV
+ eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
+ ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR,
+ ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
+ eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA
};
struct ApplicationInfo
return *this;
}
- operator const VkApplicationInfo&() const
+ operator VkApplicationInfo const&() const
{
return *reinterpret_cast<const VkApplicationInfo*>(this);
}
+ operator VkApplicationInfo &()
+ {
+ return *reinterpret_cast<VkApplicationInfo*>(this);
+ }
+
bool operator==( ApplicationInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkInstanceCreateInfo&() const
+ operator VkInstanceCreateInfo const&() const
{
return *reinterpret_cast<const VkInstanceCreateInfo*>(this);
}
+ operator VkInstanceCreateInfo &()
+ {
+ return *reinterpret_cast<VkInstanceCreateInfo*>(this);
+ }
+
bool operator==( InstanceCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkMemoryAllocateInfo&() const
+ operator VkMemoryAllocateInfo const&() const
{
return *reinterpret_cast<const VkMemoryAllocateInfo*>(this);
}
+ operator VkMemoryAllocateInfo &()
+ {
+ return *reinterpret_cast<VkMemoryAllocateInfo*>(this);
+ }
+
bool operator==( MemoryAllocateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkMappedMemoryRange&() const
+ operator VkMappedMemoryRange const&() const
{
return *reinterpret_cast<const VkMappedMemoryRange*>(this);
}
+ operator VkMappedMemoryRange &()
+ {
+ return *reinterpret_cast<VkMappedMemoryRange*>(this);
+ }
+
bool operator==( MappedMemoryRange const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkWriteDescriptorSet&() const
+ operator VkWriteDescriptorSet const&() const
{
return *reinterpret_cast<const VkWriteDescriptorSet*>(this);
}
+ operator VkWriteDescriptorSet &()
+ {
+ return *reinterpret_cast<VkWriteDescriptorSet*>(this);
+ }
+
bool operator==( WriteDescriptorSet const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkCopyDescriptorSet&() const
+ operator VkCopyDescriptorSet const&() const
{
return *reinterpret_cast<const VkCopyDescriptorSet*>(this);
}
+ operator VkCopyDescriptorSet &()
+ {
+ return *reinterpret_cast<VkCopyDescriptorSet*>(this);
+ }
+
bool operator==( CopyDescriptorSet const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBufferViewCreateInfo&() const
+ operator VkBufferViewCreateInfo const&() const
{
return *reinterpret_cast<const VkBufferViewCreateInfo*>(this);
}
+ operator VkBufferViewCreateInfo &()
+ {
+ return *reinterpret_cast<VkBufferViewCreateInfo*>(this);
+ }
+
bool operator==( BufferViewCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkShaderModuleCreateInfo&() const
+ operator VkShaderModuleCreateInfo const&() const
{
return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this);
}
+ operator VkShaderModuleCreateInfo &()
+ {
+ return *reinterpret_cast<VkShaderModuleCreateInfo*>(this);
+ }
+
bool operator==( ShaderModuleCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDescriptorSetAllocateInfo&() const
+ operator VkDescriptorSetAllocateInfo const&() const
{
return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this);
}
+ operator VkDescriptorSetAllocateInfo &()
+ {
+ return *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this);
+ }
+
bool operator==( DescriptorSetAllocateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineVertexInputStateCreateInfo&() const
+ operator VkPipelineVertexInputStateCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this);
}
+ operator VkPipelineVertexInputStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this);
+ }
+
bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineInputAssemblyStateCreateInfo&() const
+ operator VkPipelineInputAssemblyStateCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this);
}
+ operator VkPipelineInputAssemblyStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this);
+ }
+
bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineTessellationStateCreateInfo&() const
+ operator VkPipelineTessellationStateCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this);
}
+ operator VkPipelineTessellationStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this);
+ }
+
bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineViewportStateCreateInfo&() const
+ operator VkPipelineViewportStateCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this);
}
+ operator VkPipelineViewportStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this);
+ }
+
bool operator==( PipelineViewportStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineRasterizationStateCreateInfo&() const
+ operator VkPipelineRasterizationStateCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this);
}
+ operator VkPipelineRasterizationStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this);
+ }
+
bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineDepthStencilStateCreateInfo&() const
+ operator VkPipelineDepthStencilStateCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this);
}
+ operator VkPipelineDepthStencilStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this);
+ }
+
bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineCacheCreateInfo&() const
+ operator VkPipelineCacheCreateInfo const&() const
{
return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this);
}
+ operator VkPipelineCacheCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineCacheCreateInfo*>(this);
+ }
+
bool operator==( PipelineCacheCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkSamplerCreateInfo&() const
+ operator VkSamplerCreateInfo const&() const
{
return *reinterpret_cast<const VkSamplerCreateInfo*>(this);
}
+ operator VkSamplerCreateInfo &()
+ {
+ return *reinterpret_cast<VkSamplerCreateInfo*>(this);
+ }
+
bool operator==( SamplerCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkCommandBufferAllocateInfo&() const
+ operator VkCommandBufferAllocateInfo const&() const
{
return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this);
}
+ operator VkCommandBufferAllocateInfo &()
+ {
+ return *reinterpret_cast<VkCommandBufferAllocateInfo*>(this);
+ }
+
bool operator==( CommandBufferAllocateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkRenderPassBeginInfo&() const
+ operator VkRenderPassBeginInfo const&() const
{
return *reinterpret_cast<const VkRenderPassBeginInfo*>(this);
}
+ operator VkRenderPassBeginInfo &()
+ {
+ return *reinterpret_cast<VkRenderPassBeginInfo*>(this);
+ }
+
bool operator==( RenderPassBeginInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkEventCreateInfo&() const
+ operator VkEventCreateInfo const&() const
{
return *reinterpret_cast<const VkEventCreateInfo*>(this);
}
+ operator VkEventCreateInfo &()
+ {
+ return *reinterpret_cast<VkEventCreateInfo*>(this);
+ }
+
bool operator==( EventCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkSemaphoreCreateInfo&() const
+ operator VkSemaphoreCreateInfo const&() const
{
return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this);
}
+ operator VkSemaphoreCreateInfo &()
+ {
+ return *reinterpret_cast<VkSemaphoreCreateInfo*>(this);
+ }
+
bool operator==( SemaphoreCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkFramebufferCreateInfo&() const
+ operator VkFramebufferCreateInfo const&() const
{
return *reinterpret_cast<const VkFramebufferCreateInfo*>(this);
}
+ operator VkFramebufferCreateInfo &()
+ {
+ return *reinterpret_cast<VkFramebufferCreateInfo*>(this);
+ }
+
bool operator==( FramebufferCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDisplayModeCreateInfoKHR&() const
+ operator VkDisplayModeCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this);
}
+ operator VkDisplayModeCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this);
+ }
+
bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDisplayPresentInfoKHR&() const
+ operator VkDisplayPresentInfoKHR const&() const
{
return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this);
}
+ operator VkDisplayPresentInfoKHR &()
+ {
+ return *reinterpret_cast<VkDisplayPresentInfoKHR*>(this);
+ }
+
bool operator==( DisplayPresentInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkAndroidSurfaceCreateInfoKHR&() const
+ operator VkAndroidSurfaceCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this);
}
+ operator VkAndroidSurfaceCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this);
+ }
+
bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- struct MirSurfaceCreateInfoKHR
- {
- MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(),
- MirConnection* connection_ = nullptr,
- MirSurface* mirSurface_ = nullptr )
- : flags( flags_ )
- , connection( connection_ )
- , mirSurface( mirSurface_ )
- {
- }
-
- MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) );
- }
-
- MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) );
- return *this;
- }
- MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
-
- MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ )
- {
- connection = connection_;
- return *this;
- }
-
- MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ )
- {
- mirSurface = mirSurface_;
- return *this;
- }
-
- operator const VkMirSurfaceCreateInfoKHR&() const
- {
- return *reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>(this);
- }
-
- bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( connection == rhs.connection )
- && ( mirSurface == rhs.mirSurface );
- }
-
- bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- private:
- StructureType sType = StructureType::eMirSurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- MirSurfaceCreateFlagsKHR flags;
- MirConnection* connection;
- MirSurface* mirSurface;
- };
- static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
#ifdef VK_USE_PLATFORM_VI_NN
struct ViSurfaceCreateInfoNN
{
return *this;
}
- operator const VkViSurfaceCreateInfoNN&() const
+ operator VkViSurfaceCreateInfoNN const&() const
{
return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(this);
}
+ operator VkViSurfaceCreateInfoNN &()
+ {
+ return *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this);
+ }
+
bool operator==( ViSurfaceCreateInfoNN const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkWaylandSurfaceCreateInfoKHR&() const
+ operator VkWaylandSurfaceCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this);
}
+ operator VkWaylandSurfaceCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this);
+ }
+
bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkWin32SurfaceCreateInfoKHR&() const
+ operator VkWin32SurfaceCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this);
}
+ operator VkWin32SurfaceCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this);
+ }
+
bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkXlibSurfaceCreateInfoKHR&() const
+ operator VkXlibSurfaceCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this);
}
+ operator VkXlibSurfaceCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this);
+ }
+
bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkXcbSurfaceCreateInfoKHR&() const
+ operator VkXcbSurfaceCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this);
}
+ operator VkXcbSurfaceCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this);
+ }
+
bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ struct ImagePipeSurfaceCreateInfoFUCHSIA
+ {
+ ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(),
+ zx_handle_t imagePipeHandle_ = 0 )
+ : flags( flags_ )
+ , imagePipeHandle( imagePipeHandle_ )
+ {
+ }
+
+ ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
+ }
+
+ ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
+ return *this;
+ }
+ ImagePipeSurfaceCreateInfoFUCHSIA& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImagePipeSurfaceCreateInfoFUCHSIA& setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ImagePipeSurfaceCreateInfoFUCHSIA& setImagePipeHandle( zx_handle_t imagePipeHandle_ )
+ {
+ imagePipeHandle = imagePipeHandle_;
+ return *this;
+ }
+
+ operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const
+ {
+ return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(this);
+ }
+
+ operator VkImagePipeSurfaceCreateInfoFUCHSIA &()
+ {
+ return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this);
+ }
+
+ bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( imagePipeHandle == rhs.imagePipeHandle );
+ }
+
+ bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
+
+ public:
+ const void* pNext = nullptr;
+ ImagePipeSurfaceCreateFlagsFUCHSIA flags;
+ zx_handle_t imagePipeHandle;
+ };
+ static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
struct DebugMarkerMarkerInfoEXT
{
DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
return *this;
}
- operator const VkDebugMarkerMarkerInfoEXT&() const
+ operator VkDebugMarkerMarkerInfoEXT const&() const
{
return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this);
}
+ operator VkDebugMarkerMarkerInfoEXT &()
+ {
+ return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this);
+ }
+
bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDedicatedAllocationImageCreateInfoNV&() const
+ operator VkDedicatedAllocationImageCreateInfoNV const&() const
{
return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this);
}
+ operator VkDedicatedAllocationImageCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this);
+ }
+
bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDedicatedAllocationBufferCreateInfoNV&() const
+ operator VkDedicatedAllocationBufferCreateInfoNV const&() const
{
return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this);
}
+ operator VkDedicatedAllocationBufferCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this);
+ }
+
bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const
+ operator VkDedicatedAllocationMemoryAllocateInfoNV const&() const
{
return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
}
+ operator VkDedicatedAllocationMemoryAllocateInfoNV &()
+ {
+ return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
+ }
+
bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkExportMemoryWin32HandleInfoNV&() const
+ operator VkExportMemoryWin32HandleInfoNV const&() const
{
return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
}
+ operator VkExportMemoryWin32HandleInfoNV &()
+ {
+ return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this);
+ }
+
bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const
+ operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const
{
return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
}
+ operator VkWin32KeyedMutexAcquireReleaseInfoNV &()
+ {
+ return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
+ }
+
bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDeviceGeneratedCommandsFeaturesNVX&() const
+ operator VkDeviceGeneratedCommandsFeaturesNVX const&() const
{
return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>(this);
}
+ operator VkDeviceGeneratedCommandsFeaturesNVX &()
+ {
+ return *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this);
+ }
+
bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDeviceGeneratedCommandsLimitsNVX&() const
+ operator VkDeviceGeneratedCommandsLimitsNVX const&() const
{
return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>(this);
}
+ operator VkDeviceGeneratedCommandsLimitsNVX &()
+ {
+ return *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this);
+ }
+
bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkCmdReserveSpaceForCommandsInfoNVX&() const
+ operator VkCmdReserveSpaceForCommandsInfoNVX const&() const
{
return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>(this);
}
+ operator VkCmdReserveSpaceForCommandsInfoNVX &()
+ {
+ return *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this);
+ }
+
bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceFeatures2&() const
+ operator VkPhysicalDeviceFeatures2 const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>(this);
}
+ operator VkPhysicalDeviceFeatures2 &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this);
+ }
+
bool operator==( PhysicalDeviceFeatures2 const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const
+ operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
}
+ operator VkPhysicalDevicePushDescriptorPropertiesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
+ }
+
bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPresentRegionsKHR&() const
+ operator VkPresentRegionsKHR const&() const
{
return *reinterpret_cast<const VkPresentRegionsKHR*>(this);
}
+ operator VkPresentRegionsKHR &()
+ {
+ return *reinterpret_cast<VkPresentRegionsKHR*>(this);
+ }
+
bool operator==( PresentRegionsKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceVariablePointerFeatures&() const
+ operator VkPhysicalDeviceVariablePointerFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(this);
}
+ operator VkPhysicalDeviceVariablePointerFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(this);
+ }
+
bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceIDProperties
{
- operator const VkPhysicalDeviceIDProperties&() const
+ operator VkPhysicalDeviceIDProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>(this);
}
+ operator VkPhysicalDeviceIDProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this);
+ }
+
bool operator==( PhysicalDeviceIDProperties const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkExportMemoryWin32HandleInfoKHR&() const
+ operator VkExportMemoryWin32HandleInfoKHR const&() const
{
return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(this);
}
+ operator VkExportMemoryWin32HandleInfoKHR &()
+ {
+ return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this);
+ }
+
bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
#ifdef VK_USE_PLATFORM_WIN32_KHR
struct MemoryWin32HandlePropertiesKHR
{
- operator const VkMemoryWin32HandlePropertiesKHR&() const
+ operator VkMemoryWin32HandlePropertiesKHR const&() const
{
return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this);
}
+ operator VkMemoryWin32HandlePropertiesKHR &()
+ {
+ return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this);
+ }
+
bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const
{
return ( sType == rhs.sType )
struct MemoryFdPropertiesKHR
{
- operator const VkMemoryFdPropertiesKHR&() const
+ operator VkMemoryFdPropertiesKHR const&() const
{
return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this);
}
+ operator VkMemoryFdPropertiesKHR &()
+ {
+ return *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this);
+ }
+
bool operator==( MemoryFdPropertiesKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const
+ operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const
{
return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
}
+ operator VkWin32KeyedMutexAcquireReleaseInfoKHR &()
+ {
+ return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
+ }
+
bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkExportSemaphoreWin32HandleInfoKHR&() const
+ operator VkExportSemaphoreWin32HandleInfoKHR const&() const
{
return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(this);
}
+ operator VkExportSemaphoreWin32HandleInfoKHR &()
+ {
+ return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this);
+ }
+
bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkD3D12FenceSubmitInfoKHR&() const
+ operator VkD3D12FenceSubmitInfoKHR const&() const
{
return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(this);
}
+ operator VkD3D12FenceSubmitInfoKHR &()
+ {
+ return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this);
+ }
+
bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkExportFenceWin32HandleInfoKHR&() const
+ operator VkExportFenceWin32HandleInfoKHR const&() const
{
return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(this);
}
+ operator VkExportFenceWin32HandleInfoKHR &()
+ {
+ return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this);
+ }
+
bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceMultiviewFeatures&() const
+ operator VkPhysicalDeviceMultiviewFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(this);
}
+ operator VkPhysicalDeviceMultiviewFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this);
+ }
+
bool operator==( PhysicalDeviceMultiviewFeatures const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceMultiviewProperties
{
- operator const VkPhysicalDeviceMultiviewProperties&() const
+ operator VkPhysicalDeviceMultiviewProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(this);
}
+ operator VkPhysicalDeviceMultiviewProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this);
+ }
+
bool operator==( PhysicalDeviceMultiviewProperties const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkRenderPassMultiviewCreateInfo&() const
+ operator VkRenderPassMultiviewCreateInfo const&() const
{
return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(this);
}
+ operator VkRenderPassMultiviewCreateInfo &()
+ {
+ return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this);
+ }
+
bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBindBufferMemoryInfo&() const
+ operator VkBindBufferMemoryInfo const&() const
{
return *reinterpret_cast<const VkBindBufferMemoryInfo*>(this);
}
+ operator VkBindBufferMemoryInfo &()
+ {
+ return *reinterpret_cast<VkBindBufferMemoryInfo*>(this);
+ }
+
bool operator==( BindBufferMemoryInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBindBufferMemoryDeviceGroupInfo&() const
+ operator VkBindBufferMemoryDeviceGroupInfo const&() const
{
return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(this);
}
+ operator VkBindBufferMemoryDeviceGroupInfo &()
+ {
+ return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this);
+ }
+
bool operator==( BindBufferMemoryDeviceGroupInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBindImageMemoryInfo&() const
+ operator VkBindImageMemoryInfo const&() const
{
return *reinterpret_cast<const VkBindImageMemoryInfo*>(this);
}
+ operator VkBindImageMemoryInfo &()
+ {
+ return *reinterpret_cast<VkBindImageMemoryInfo*>(this);
+ }
+
bool operator==( BindImageMemoryInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBindImageMemoryDeviceGroupInfo&() const
+ operator VkBindImageMemoryDeviceGroupInfo const&() const
{
return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(this);
}
+ operator VkBindImageMemoryDeviceGroupInfo &()
+ {
+ return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this);
+ }
+
bool operator==( BindImageMemoryDeviceGroupInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDeviceGroupRenderPassBeginInfo&() const
+ operator VkDeviceGroupRenderPassBeginInfo const&() const
{
return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(this);
}
+ operator VkDeviceGroupRenderPassBeginInfo &()
+ {
+ return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this);
+ }
+
bool operator==( DeviceGroupRenderPassBeginInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDeviceGroupCommandBufferBeginInfo&() const
+ operator VkDeviceGroupCommandBufferBeginInfo const&() const
{
return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(this);
}
+ operator VkDeviceGroupCommandBufferBeginInfo &()
+ {
+ return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this);
+ }
+
bool operator==( DeviceGroupCommandBufferBeginInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDeviceGroupSubmitInfo&() const
+ operator VkDeviceGroupSubmitInfo const&() const
{
return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>(this);
}
+ operator VkDeviceGroupSubmitInfo &()
+ {
+ return *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this);
+ }
+
bool operator==( DeviceGroupSubmitInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDeviceGroupBindSparseInfo&() const
+ operator VkDeviceGroupBindSparseInfo const&() const
{
return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(this);
}
+ operator VkDeviceGroupBindSparseInfo &()
+ {
+ return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this);
+ }
+
bool operator==( DeviceGroupBindSparseInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkImageSwapchainCreateInfoKHR&() const
+ operator VkImageSwapchainCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(this);
}
+ operator VkImageSwapchainCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this);
+ }
+
bool operator==( ImageSwapchainCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBindImageMemorySwapchainInfoKHR&() const
+ operator VkBindImageMemorySwapchainInfoKHR const&() const
{
return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(this);
}
+ operator VkBindImageMemorySwapchainInfoKHR &()
+ {
+ return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this);
+ }
+
bool operator==( BindImageMemorySwapchainInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkAcquireNextImageInfoKHR&() const
+ operator VkAcquireNextImageInfoKHR const&() const
{
return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>(this);
}
+ operator VkAcquireNextImageInfoKHR &()
+ {
+ return *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this);
+ }
+
bool operator==( AcquireNextImageInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkHdrMetadataEXT&() const
+ operator VkHdrMetadataEXT const&() const
{
return *reinterpret_cast<const VkHdrMetadataEXT*>(this);
}
+ operator VkHdrMetadataEXT &()
+ {
+ return *reinterpret_cast<VkHdrMetadataEXT*>(this);
+ }
+
bool operator==( HdrMetadataEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPresentTimesInfoGOOGLE&() const
+ operator VkPresentTimesInfoGOOGLE const&() const
{
return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(this);
}
+ operator VkPresentTimesInfoGOOGLE &()
+ {
+ return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this);
+ }
+
bool operator==( PresentTimesInfoGOOGLE const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkIOSSurfaceCreateInfoMVK&() const
+ operator VkIOSSurfaceCreateInfoMVK const&() const
{
return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this);
}
+ operator VkIOSSurfaceCreateInfoMVK &()
+ {
+ return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this);
+ }
+
bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkMacOSSurfaceCreateInfoMVK&() const
+ operator VkMacOSSurfaceCreateInfoMVK const&() const
{
return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this);
}
+ operator VkMacOSSurfaceCreateInfoMVK &()
+ {
+ return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this);
+ }
+
bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineViewportWScalingStateCreateInfoNV&() const
+ operator VkPipelineViewportWScalingStateCreateInfoNV const&() const
{
return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this);
}
+ operator VkPipelineViewportWScalingStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this);
+ }
+
bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const
+ operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
{
- operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const
+ operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
}
+ operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
+ }
+
bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceSurfaceInfo2KHR&() const
+ operator VkPhysicalDeviceSurfaceInfo2KHR const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(this);
}
+ operator VkPhysicalDeviceSurfaceInfo2KHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this);
+ }
+
bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
{
return ( sType == rhs.sType )
struct DisplayPlaneProperties2KHR
{
- operator const VkDisplayPlaneProperties2KHR&() const
+ operator VkDisplayPlaneProperties2KHR const&() const
{
return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(this);
}
+ operator VkDisplayPlaneProperties2KHR &()
+ {
+ return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this);
+ }
+
bool operator==( DisplayPlaneProperties2KHR const& rhs ) const
{
return ( sType == rhs.sType )
struct DisplayModeProperties2KHR
{
- operator const VkDisplayModeProperties2KHR&() const
+ operator VkDisplayModeProperties2KHR const&() const
{
return *reinterpret_cast<const VkDisplayModeProperties2KHR*>(this);
}
+ operator VkDisplayModeProperties2KHR &()
+ {
+ return *reinterpret_cast<VkDisplayModeProperties2KHR*>(this);
+ }
+
bool operator==( DisplayModeProperties2KHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDisplayPlaneInfo2KHR&() const
+ operator VkDisplayPlaneInfo2KHR const&() const
{
return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(this);
}
+ operator VkDisplayPlaneInfo2KHR &()
+ {
+ return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this);
+ }
+
bool operator==( DisplayPlaneInfo2KHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDevice16BitStorageFeatures&() const
+ operator VkPhysicalDevice16BitStorageFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(this);
}
+ operator VkPhysicalDevice16BitStorageFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this);
+ }
+
bool operator==( PhysicalDevice16BitStorageFeatures const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBufferMemoryRequirementsInfo2&() const
+ operator VkBufferMemoryRequirementsInfo2 const&() const
{
return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(this);
}
+ operator VkBufferMemoryRequirementsInfo2 &()
+ {
+ return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this);
+ }
+
bool operator==( BufferMemoryRequirementsInfo2 const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkImageMemoryRequirementsInfo2&() const
+ operator VkImageMemoryRequirementsInfo2 const&() const
{
return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(this);
}
+ operator VkImageMemoryRequirementsInfo2 &()
+ {
+ return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this);
+ }
+
bool operator==( ImageMemoryRequirementsInfo2 const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkImageSparseMemoryRequirementsInfo2&() const
+ operator VkImageSparseMemoryRequirementsInfo2 const&() const
{
return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(this);
}
+ operator VkImageSparseMemoryRequirementsInfo2 &()
+ {
+ return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this);
+ }
+
bool operator==( ImageSparseMemoryRequirementsInfo2 const& rhs ) const
{
return ( sType == rhs.sType )
struct MemoryRequirements2
{
- operator const VkMemoryRequirements2&() const
+ operator VkMemoryRequirements2 const&() const
{
return *reinterpret_cast<const VkMemoryRequirements2*>(this);
}
+ operator VkMemoryRequirements2 &()
+ {
+ return *reinterpret_cast<VkMemoryRequirements2*>(this);
+ }
+
bool operator==( MemoryRequirements2 const& rhs ) const
{
return ( sType == rhs.sType )
struct MemoryDedicatedRequirements
{
- operator const VkMemoryDedicatedRequirements&() const
+ operator VkMemoryDedicatedRequirements const&() const
{
return *reinterpret_cast<const VkMemoryDedicatedRequirements*>(this);
}
+ operator VkMemoryDedicatedRequirements &()
+ {
+ return *reinterpret_cast<VkMemoryDedicatedRequirements*>(this);
+ }
+
bool operator==( MemoryDedicatedRequirements const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkMemoryDedicatedAllocateInfo&() const
+ operator VkMemoryDedicatedAllocateInfo const&() const
{
return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(this);
}
+ operator VkMemoryDedicatedAllocateInfo &()
+ {
+ return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this);
+ }
+
bool operator==( MemoryDedicatedAllocateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkSamplerYcbcrConversionInfo&() const
+ operator VkSamplerYcbcrConversionInfo const&() const
{
return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(this);
}
+ operator VkSamplerYcbcrConversionInfo &()
+ {
+ return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this);
+ }
+
bool operator==( SamplerYcbcrConversionInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceSamplerYcbcrConversionFeatures&() const
+ operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
}
+ operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
+ }
+
bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const
{
return ( sType == rhs.sType )
struct SamplerYcbcrConversionImageFormatProperties
{
- operator const VkSamplerYcbcrConversionImageFormatProperties&() const
+ operator VkSamplerYcbcrConversionImageFormatProperties const&() const
{
return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(this);
}
+ operator VkSamplerYcbcrConversionImageFormatProperties &()
+ {
+ return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this);
+ }
+
bool operator==( SamplerYcbcrConversionImageFormatProperties const& rhs ) const
{
return ( sType == rhs.sType )
struct TextureLODGatherFormatPropertiesAMD
{
- operator const VkTextureLODGatherFormatPropertiesAMD&() const
+ operator VkTextureLODGatherFormatPropertiesAMD const&() const
{
return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
}
+ operator VkTextureLODGatherFormatPropertiesAMD &()
+ {
+ return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this);
+ }
+
bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkProtectedSubmitInfo&() const
+ operator VkProtectedSubmitInfo const&() const
{
return *reinterpret_cast<const VkProtectedSubmitInfo*>(this);
}
+ operator VkProtectedSubmitInfo &()
+ {
+ return *reinterpret_cast<VkProtectedSubmitInfo*>(this);
+ }
+
bool operator==( ProtectedSubmitInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceProtectedMemoryFeatures&() const
+ operator VkPhysicalDeviceProtectedMemoryFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(this);
}
+ operator VkPhysicalDeviceProtectedMemoryFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this);
+ }
+
bool operator==( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceProtectedMemoryProperties&() const
+ operator VkPhysicalDeviceProtectedMemoryProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(this);
}
+ operator VkPhysicalDeviceProtectedMemoryProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this);
+ }
+
bool operator==( PhysicalDeviceProtectedMemoryProperties const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineCoverageToColorStateCreateInfoNV&() const
+ operator VkPipelineCoverageToColorStateCreateInfoNV const&() const
{
return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(this);
}
+ operator VkPipelineCoverageToColorStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this);
+ }
+
bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
{
- operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const
+ operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct MultisamplePropertiesEXT
{
- operator const VkMultisamplePropertiesEXT&() const
+ operator VkMultisamplePropertiesEXT const&() const
{
return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this);
}
+ operator VkMultisamplePropertiesEXT &()
+ {
+ return *reinterpret_cast<VkMultisamplePropertiesEXT*>(this);
+ }
+
bool operator==( MultisamplePropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const
+ operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
}
+ operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
{
- operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const
+ operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
};
static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" );
+ struct PhysicalDeviceInlineUniformBlockFeaturesEXT
+ {
+ operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
+ }
+
+ operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
+ }
+
+ bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( inlineUniformBlock == rhs.inlineUniformBlock )
+ && ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind );
+ }
+
+ bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
+
+ public:
+ void* pNext = nullptr;
+ Bool32 inlineUniformBlock;
+ Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+ };
+ static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceInlineUniformBlockPropertiesEXT
+ {
+ operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
+ }
+
+ operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
+ }
+
+ bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize )
+ && ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks )
+ && ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks )
+ && ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks )
+ && ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+ }
+
+ bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
+
+ public:
+ void* pNext = nullptr;
+ uint32_t maxInlineUniformBlockSize;
+ uint32_t maxPerStageDescriptorInlineUniformBlocks;
+ uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+ uint32_t maxDescriptorSetInlineUniformBlocks;
+ uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+ };
+ static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" );
+
+ struct WriteDescriptorSetInlineUniformBlockEXT
+ {
+ WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
+ const void* pData_ = nullptr )
+ : dataSize( dataSize_ )
+ , pData( pData_ )
+ {
+ }
+
+ WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
+ }
+
+ WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
+ return *this;
+ }
+ WriteDescriptorSetInlineUniformBlockEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ WriteDescriptorSetInlineUniformBlockEXT& setDataSize( uint32_t dataSize_ )
+ {
+ dataSize = dataSize_;
+ return *this;
+ }
+
+ WriteDescriptorSetInlineUniformBlockEXT& setPData( const void* pData_ )
+ {
+ pData = pData_;
+ return *this;
+ }
+
+ operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const
+ {
+ return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
+ }
+
+ operator VkWriteDescriptorSetInlineUniformBlockEXT &()
+ {
+ return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
+ }
+
+ bool operator==( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( dataSize == rhs.dataSize )
+ && ( pData == rhs.pData );
+ }
+
+ bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t dataSize;
+ const void* pData;
+ };
+ static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
+
+ struct DescriptorPoolInlineUniformBlockCreateInfoEXT
+ {
+ DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
+ : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
+ {
+ }
+
+ DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
+ }
+
+ DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
+ return *this;
+ }
+ DescriptorPoolInlineUniformBlockCreateInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DescriptorPoolInlineUniformBlockCreateInfoEXT& setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ )
+ {
+ maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
+ return *this;
+ }
+
+ operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
+ }
+
+ operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
+ }
+
+ bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
+ }
+
+ bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t maxInlineUniformBlockBindings;
+ };
+ static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
+
struct ImageFormatListCreateInfoKHR
{
ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
return *this;
}
- operator const VkImageFormatListCreateInfoKHR&() const
+ operator VkImageFormatListCreateInfoKHR const&() const
{
return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(this);
}
+ operator VkImageFormatListCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this);
+ }
+
bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkValidationCacheCreateInfoEXT&() const
+ operator VkValidationCacheCreateInfoEXT const&() const
{
return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(this);
}
+ operator VkValidationCacheCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this);
+ }
+
bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkShaderModuleValidationCacheCreateInfoEXT&() const
+ operator VkShaderModuleValidationCacheCreateInfoEXT const&() const
{
return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(this);
}
+ operator VkShaderModuleValidationCacheCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this);
+ }
+
bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceMaintenance3Properties
{
- operator const VkPhysicalDeviceMaintenance3Properties&() const
+ operator VkPhysicalDeviceMaintenance3Properties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(this);
}
+ operator VkPhysicalDeviceMaintenance3Properties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this);
+ }
+
bool operator==( PhysicalDeviceMaintenance3Properties const& rhs ) const
{
return ( sType == rhs.sType )
struct DescriptorSetLayoutSupport
{
- operator const VkDescriptorSetLayoutSupport&() const
+ operator VkDescriptorSetLayoutSupport const&() const
{
return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>(this);
}
+ operator VkDescriptorSetLayoutSupport &()
+ {
+ return *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this);
+ }
+
bool operator==( DescriptorSetLayoutSupport const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceShaderDrawParameterFeatures&() const
+ operator VkPhysicalDeviceShaderDrawParameterFeatures const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
}
+ operator VkPhysicalDeviceShaderDrawParameterFeatures &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
+ }
+
bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDebugUtilsLabelEXT&() const
+ operator VkDebugUtilsLabelEXT const&() const
{
return *reinterpret_cast<const VkDebugUtilsLabelEXT*>(this);
}
+ operator VkDebugUtilsLabelEXT &()
+ {
+ return *reinterpret_cast<VkDebugUtilsLabelEXT*>(this);
+ }
+
bool operator==( DebugUtilsLabelEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkMemoryHostPointerPropertiesEXT&() const
+ operator VkMemoryHostPointerPropertiesEXT const&() const
{
return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this);
}
+ operator VkMemoryHostPointerPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this);
+ }
+
bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const
+ operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const
+ operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceShaderCorePropertiesAMD
{
- operator const VkPhysicalDeviceShaderCorePropertiesAMD&() const
+ operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
}
+ operator VkPhysicalDeviceShaderCorePropertiesAMD &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
+ }
+
bool operator==( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceDescriptorIndexingFeaturesEXT&() const
+ operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
}
+ operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceDescriptorIndexingPropertiesEXT
{
- operator const VkPhysicalDeviceDescriptorIndexingPropertiesEXT&() const
+ operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT&() const
+ operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const&() const
{
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
}
+ operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT &()
+ {
+ return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
+ }
+
bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
{
- operator const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT&() const
+ operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const
{
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
}
+ operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT &()
+ {
+ return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
+ }
+
bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkSubpassEndInfoKHR&() const
+ operator VkSubpassEndInfoKHR const&() const
{
return *reinterpret_cast<const VkSubpassEndInfoKHR*>(this);
}
+ operator VkSubpassEndInfoKHR &()
+ {
+ return *reinterpret_cast<VkSubpassEndInfoKHR*>(this);
+ }
+
bool operator==( SubpassEndInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPipelineVertexInputDivisorStateCreateInfoEXT&() const
+ operator VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const
{
return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
}
+ operator VkPipelineVertexInputDivisorStateCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
+ }
+
bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT&() const
+ operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
}
+ operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
};
static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
+ struct PhysicalDevicePCIBusInfoPropertiesEXT
+ {
+ operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this);
+ }
+
+ operator VkPhysicalDevicePCIBusInfoPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this);
+ }
+
+ bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( pciDomain == rhs.pciDomain )
+ && ( pciBus == rhs.pciBus )
+ && ( pciDevice == rhs.pciDevice )
+ && ( pciFunction == rhs.pciFunction );
+ }
+
+ bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
+
+ public:
+ void* pNext = nullptr;
+ uint16_t pciDomain;
+ uint8_t pciBus;
+ uint8_t pciDevice;
+ uint8_t pciFunction;
+ };
+ static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" );
+
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
struct ImportAndroidHardwareBufferInfoANDROID
{
return *this;
}
- operator const VkImportAndroidHardwareBufferInfoANDROID&() const
+ operator VkImportAndroidHardwareBufferInfoANDROID const&() const
{
return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(this);
}
+ operator VkImportAndroidHardwareBufferInfoANDROID &()
+ {
+ return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this);
+ }
+
bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
{
return ( sType == rhs.sType )
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
struct AndroidHardwareBufferUsageANDROID
{
- operator const VkAndroidHardwareBufferUsageANDROID&() const
+ operator VkAndroidHardwareBufferUsageANDROID const&() const
{
return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(this);
}
+ operator VkAndroidHardwareBufferUsageANDROID &()
+ {
+ return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this);
+ }
+
bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const
{
return ( sType == rhs.sType )
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
struct AndroidHardwareBufferPropertiesANDROID
{
- operator const VkAndroidHardwareBufferPropertiesANDROID&() const
+ operator VkAndroidHardwareBufferPropertiesANDROID const&() const
{
return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(this);
}
+ operator VkAndroidHardwareBufferPropertiesANDROID &()
+ {
+ return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this);
+ }
+
bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkMemoryGetAndroidHardwareBufferInfoANDROID&() const
+ operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const
{
return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
}
+ operator VkMemoryGetAndroidHardwareBufferInfoANDROID &()
+ {
+ return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
+ }
+
bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkCommandBufferInheritanceConditionalRenderingInfoEXT&() const
+ operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const
{
return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
}
+ operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &()
+ {
+ return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
+ }
+
bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkExternalFormatANDROID&() const
+ operator VkExternalFormatANDROID const&() const
{
return *reinterpret_cast<const VkExternalFormatANDROID*>(this);
}
+ operator VkExternalFormatANDROID &()
+ {
+ return *reinterpret_cast<VkExternalFormatANDROID*>(this);
+ }
+
bool operator==( ExternalFormatANDROID const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDevice8BitStorageFeaturesKHR&() const
+ operator VkPhysicalDevice8BitStorageFeaturesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
}
+ operator VkPhysicalDevice8BitStorageFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
+ }
+
bool operator==( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkPhysicalDeviceConditionalRenderingFeaturesEXT&() const
+ operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
}
+ operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
+ }
+
bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
};
static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
- enum class SubpassContents
+ struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
{
- eInline = VK_SUBPASS_CONTENTS_INLINE,
- eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+ operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
+ }
+
+ operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
+ }
+
+ bool operator==( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( vulkanMemoryModel == rhs.vulkanMemoryModel )
+ && ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope );
+ }
+
+ bool operator!=( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
+
+ public:
+ void* pNext = nullptr;
+ Bool32 vulkanMemoryModel;
+ Bool32 vulkanMemoryModelDeviceScope;
};
+ static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" );
- struct SubpassBeginInfoKHR
+ struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
{
- SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
- : contents( contents_ )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR( Bool32 shaderBufferInt64Atomics_ = 0,
+ Bool32 shaderSharedInt64Atomics_ = 0 )
+ : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
+ , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
{
}
- SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
}
- SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
return *this;
}
- SubpassBeginInfoKHR& setPNext( const void* pNext_ )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SubpassBeginInfoKHR& setContents( SubpassContents contents_ )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR& setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ )
{
- contents = contents_;
+ shaderBufferInt64Atomics = shaderBufferInt64Atomics_;
return *this;
}
- operator const VkSubpassBeginInfoKHR&() const
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR& setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ )
{
- return *reinterpret_cast<const VkSubpassBeginInfoKHR*>(this);
+ shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
+ return *this;
}
- bool operator==( SubpassBeginInfoKHR const& rhs ) const
+ operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this);
+ }
+
+ operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this);
+ }
+
+ bool operator==( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( contents == rhs.contents );
+ && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics )
+ && ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics );
}
- bool operator!=( SubpassBeginInfoKHR const& rhs ) const
+ bool operator!=( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSubpassBeginInfoKHR;
+ StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
public:
- const void* pNext = nullptr;
- SubpassContents contents;
+ void* pNext = nullptr;
+ Bool32 shaderBufferInt64Atomics;
+ Bool32 shaderSharedInt64Atomics;
};
- static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" );
- struct PresentInfoKHR
+ struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
{
- PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
- const Semaphore* pWaitSemaphores_ = nullptr,
- uint32_t swapchainCount_ = 0,
- const SwapchainKHR* pSwapchains_ = nullptr,
- const uint32_t* pImageIndices_ = nullptr,
- Result* pResults_ = nullptr )
- : waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , swapchainCount( swapchainCount_ )
- , pSwapchains( pSwapchains_ )
- , pImageIndices( pImageIndices_ )
- , pResults( pResults_ )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0,
+ Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
+ : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
+ , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
{
}
- PresentInfoKHR( VkPresentInfoKHR const & rhs )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
}
- PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
return *this;
}
- PresentInfoKHR& setPNext( const void* pNext_ )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT& setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ )
{
- waitSemaphoreCount = waitSemaphoreCount_;
+ vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_;
return *this;
}
- PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT& setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ )
{
- pWaitSemaphores = pWaitSemaphores_;
+ vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
return *this;
}
- PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
+ operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const
{
- swapchainCount = swapchainCount_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
}
- PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
+ operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &()
{
- pSwapchains = pSwapchains_;
- return *this;
+ return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
}
- PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
+ bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
{
- pImageIndices = pImageIndices_;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor )
+ && ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor );
+ }
+
+ bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+
+ public:
+ void* pNext = nullptr;
+ Bool32 vertexAttributeInstanceRateDivisor;
+ Bool32 vertexAttributeInstanceRateZeroDivisor;
+ };
+ static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
+
+ struct ImageViewASTCDecodeModeEXT
+ {
+ ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined )
+ : decodeMode( decodeMode_ )
+ {
+ }
+
+ ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
+ }
+
+ ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
+ return *this;
+ }
+ ImageViewASTCDecodeModeEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- PresentInfoKHR& setPResults( Result* pResults_ )
+ ImageViewASTCDecodeModeEXT& setDecodeMode( Format decodeMode_ )
{
- pResults = pResults_;
+ decodeMode = decodeMode_;
return *this;
}
- operator const VkPresentInfoKHR&() const
+ operator VkImageViewASTCDecodeModeEXT const&() const
{
- return *reinterpret_cast<const VkPresentInfoKHR*>(this);
+ return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(this);
}
- bool operator==( PresentInfoKHR const& rhs ) const
+ operator VkImageViewASTCDecodeModeEXT &()
+ {
+ return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this);
+ }
+
+ bool operator==( ImageViewASTCDecodeModeEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
- && ( pWaitSemaphores == rhs.pWaitSemaphores )
- && ( swapchainCount == rhs.swapchainCount )
- && ( pSwapchains == rhs.pSwapchains )
- && ( pImageIndices == rhs.pImageIndices )
- && ( pResults == rhs.pResults );
+ && ( decodeMode == rhs.decodeMode );
}
- bool operator!=( PresentInfoKHR const& rhs ) const
+ bool operator!=( ImageViewASTCDecodeModeEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePresentInfoKHR;
+ StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
public:
const void* pNext = nullptr;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- uint32_t swapchainCount;
- const SwapchainKHR* pSwapchains;
- const uint32_t* pImageIndices;
- Result* pResults;
- };
- static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
-
- enum class DynamicState
- {
- eViewport = VK_DYNAMIC_STATE_VIEWPORT,
- eScissor = VK_DYNAMIC_STATE_SCISSOR,
- eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
- eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
- eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
- eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
- eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
- eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
- eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
- eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
- eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
- eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT
+ Format decodeMode;
};
+ static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
- struct PipelineDynamicStateCreateInfo
+ struct PhysicalDeviceASTCDecodeFeaturesEXT
{
- PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
- uint32_t dynamicStateCount_ = 0,
- const DynamicState* pDynamicStates_ = nullptr )
- : flags( flags_ )
- , dynamicStateCount( dynamicStateCount_ )
- , pDynamicStates( pDynamicStates_ )
+ PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 )
+ : decodeModeSharedExponent( decodeModeSharedExponent_ )
{
}
- PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
+ PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
}
- PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
+ PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
return *this;
}
- PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
+ PhysicalDeviceASTCDecodeFeaturesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
+ PhysicalDeviceASTCDecodeFeaturesEXT& setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ )
{
- dynamicStateCount = dynamicStateCount_;
+ decodeModeSharedExponent = decodeModeSharedExponent_;
return *this;
}
- PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
+ operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const
{
- pDynamicStates = pDynamicStates_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
}
- operator const VkPipelineDynamicStateCreateInfo&() const
+ operator VkPhysicalDeviceASTCDecodeFeaturesEXT &()
{
- return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
}
- bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
+ bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( dynamicStateCount == rhs.dynamicStateCount )
- && ( pDynamicStates == rhs.pDynamicStates );
+ && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
}
- bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
+ bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
+ StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
public:
- const void* pNext = nullptr;
- PipelineDynamicStateCreateFlags flags;
- uint32_t dynamicStateCount;
- const DynamicState* pDynamicStates;
- };
- static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
-
- enum class DescriptorUpdateTemplateType
- {
- eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
- eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
- ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
+ void* pNext = nullptr;
+ Bool32 decodeModeSharedExponent;
};
+ static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
- struct DescriptorUpdateTemplateCreateInfo
+ struct PhysicalDeviceTransformFeedbackFeaturesEXT
{
- DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
- uint32_t descriptorUpdateEntryCount_ = 0,
- const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
- DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
- DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
- PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- uint32_t set_ = 0 )
- : flags( flags_ )
- , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
- , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
- , templateType( templateType_ )
- , descriptorSetLayout( descriptorSetLayout_ )
- , pipelineBindPoint( pipelineBindPoint_ )
- , pipelineLayout( pipelineLayout_ )
- , set( set_ )
+ PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = 0,
+ Bool32 geometryStreams_ = 0 )
+ : transformFeedback( transformFeedback_ )
+ , geometryStreams( geometryStreams_ )
{
}
- DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+ PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
}
- DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+ PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
return *this;
}
- DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ )
+ PhysicalDeviceTransformFeedbackFeaturesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
+ PhysicalDeviceTransformFeedbackFeaturesEXT& setTransformFeedback( Bool32 transformFeedback_ )
{
- flags = flags_;
+ transformFeedback = transformFeedback_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
+ PhysicalDeviceTransformFeedbackFeaturesEXT& setGeometryStreams( Bool32 geometryStreams_ )
{
- descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
+ geometryStreams = geometryStreams_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
+ operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const&() const
{
- pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
}
- DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ )
+ operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &()
{
- templateType = templateType_;
- return *this;
+ return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
}
- DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
+ bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const
{
- descriptorSetLayout = descriptorSetLayout_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( transformFeedback == rhs.transformFeedback )
+ && ( geometryStreams == rhs.geometryStreams );
}
- DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const
{
- pipelineBindPoint = pipelineBindPoint_;
- return *this;
+ return !operator==( rhs );
}
- DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ )
- {
- pipelineLayout = pipelineLayout_;
- return *this;
- }
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
- DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ )
+ public:
+ void* pNext = nullptr;
+ Bool32 transformFeedback;
+ Bool32 geometryStreams;
+ };
+ static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceTransformFeedbackPropertiesEXT
+ {
+ operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const
{
- set = set_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
}
- operator const VkDescriptorUpdateTemplateCreateInfo&() const
+ operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &()
{
- return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
}
- bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+ bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
- && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
- && ( templateType == rhs.templateType )
- && ( descriptorSetLayout == rhs.descriptorSetLayout )
- && ( pipelineBindPoint == rhs.pipelineBindPoint )
- && ( pipelineLayout == rhs.pipelineLayout )
- && ( set == rhs.set );
+ && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams )
+ && ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers )
+ && ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize )
+ && ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize )
+ && ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize )
+ && ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride )
+ && ( transformFeedbackQueries == rhs.transformFeedbackQueries )
+ && ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles )
+ && ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect )
+ && ( transformFeedbackDraw == rhs.transformFeedbackDraw );
}
- bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+ bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+ StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
public:
void* pNext = nullptr;
- DescriptorUpdateTemplateCreateFlags flags;
- uint32_t descriptorUpdateEntryCount;
- const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
- DescriptorUpdateTemplateType templateType;
- DescriptorSetLayout descriptorSetLayout;
- PipelineBindPoint pipelineBindPoint;
- PipelineLayout pipelineLayout;
- uint32_t set;
- };
- static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
-
- using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
-
- enum class ObjectType
- {
- eUnknown = VK_OBJECT_TYPE_UNKNOWN,
- eInstance = VK_OBJECT_TYPE_INSTANCE,
- ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
- eDevice = VK_OBJECT_TYPE_DEVICE,
- eQueue = VK_OBJECT_TYPE_QUEUE,
- eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
- eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
- eFence = VK_OBJECT_TYPE_FENCE,
- eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
- eBuffer = VK_OBJECT_TYPE_BUFFER,
- eImage = VK_OBJECT_TYPE_IMAGE,
- eEvent = VK_OBJECT_TYPE_EVENT,
- eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
- eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
- eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
- eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
- ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
- ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
- eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
- ePipeline = VK_OBJECT_TYPE_PIPELINE,
- eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
- eSampler = VK_OBJECT_TYPE_SAMPLER,
- eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
- eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
- eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
- eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
- eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
- eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
- eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
- eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
- eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
- eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
- eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
- eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
- eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
- eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
- eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
- eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
- eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT
- };
-
- struct DebugUtilsObjectNameInfoEXT
- {
- DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
- uint64_t objectHandle_ = 0,
- const char* pObjectName_ = nullptr )
- : objectType( objectType_ )
- , objectHandle( objectHandle_ )
- , pObjectName( pObjectName_ )
+ uint32_t maxTransformFeedbackStreams;
+ uint32_t maxTransformFeedbackBuffers;
+ DeviceSize maxTransformFeedbackBufferSize;
+ uint32_t maxTransformFeedbackStreamDataSize;
+ uint32_t maxTransformFeedbackBufferDataSize;
+ uint32_t maxTransformFeedbackBufferDataStride;
+ Bool32 transformFeedbackQueries;
+ Bool32 transformFeedbackStreamsLinesTriangles;
+ Bool32 transformFeedbackRasterizationStreamSelect;
+ Bool32 transformFeedbackDraw;
+ };
+ static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" );
+
+ struct PipelineRasterizationStateStreamCreateInfoEXT
+ {
+ PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = PipelineRasterizationStateStreamCreateFlagsEXT(),
+ uint32_t rasterizationStream_ = 0 )
+ : flags( flags_ )
+ , rasterizationStream( rasterizationStream_ )
{
}
- DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
+ PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
}
- DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
+ PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
return *this;
}
- DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ )
+ PipelineRasterizationStateStreamCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ )
+ PipelineRasterizationStateStreamCreateInfoEXT& setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
{
- objectType = objectType_;
+ flags = flags_;
return *this;
}
- DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ )
+ PipelineRasterizationStateStreamCreateInfoEXT& setRasterizationStream( uint32_t rasterizationStream_ )
{
- objectHandle = objectHandle_;
+ rasterizationStream = rasterizationStream_;
return *this;
}
- DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
+ operator VkPipelineRasterizationStateStreamCreateInfoEXT const&() const
{
- pObjectName = pObjectName_;
- return *this;
+ return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
}
- operator const VkDebugUtilsObjectNameInfoEXT&() const
+ operator VkPipelineRasterizationStateStreamCreateInfoEXT &()
{
- return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(this);
+ return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
}
- bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const
+ bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectType == rhs.objectType )
- && ( objectHandle == rhs.objectHandle )
- && ( pObjectName == rhs.pObjectName );
+ && ( flags == rhs.flags )
+ && ( rasterizationStream == rhs.rasterizationStream );
}
- bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const
+ bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+ StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
public:
const void* pNext = nullptr;
- ObjectType objectType;
- uint64_t objectHandle;
- const char* pObjectName;
+ PipelineRasterizationStateStreamCreateFlagsEXT flags;
+ uint32_t rasterizationStream;
};
- static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
- struct DebugUtilsObjectTagInfoEXT
+ struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
{
- DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
- uint64_t objectHandle_ = 0,
- uint64_t tagName_ = 0,
- size_t tagSize_ = 0,
- const void* pTag_ = nullptr )
- : objectType( objectType_ )
- , objectHandle( objectHandle_ )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 )
+ : representativeFragmentTest( representativeFragmentTest_ )
{
}
- DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
}
- DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
return *this;
}
- DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ )
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ )
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV& setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ )
{
- objectType = objectType_;
+ representativeFragmentTest = representativeFragmentTest_;
return *this;
}
- DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ )
+ operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const
{
- objectHandle = objectHandle_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
}
- DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ )
+ operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &()
{
- tagName = tagName_;
- return *this;
+ return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
}
- DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ )
+ bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
{
- tagSize = tagSize_;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( representativeFragmentTest == rhs.representativeFragmentTest );
+ }
+
+ bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+
+ public:
+ void* pNext = nullptr;
+ Bool32 representativeFragmentTest;
+ };
+ static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
+
+ struct PipelineRepresentativeFragmentTestStateCreateInfoNV
+ {
+ PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
+ : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
+ {
+ }
+
+ PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
+ }
+
+ PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
+ return *this;
+ }
+ PipelineRepresentativeFragmentTestStateCreateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ )
+ PipelineRepresentativeFragmentTestStateCreateInfoNV& setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ )
{
- pTag = pTag_;
+ representativeFragmentTestEnable = representativeFragmentTestEnable_;
return *this;
}
- operator const VkDebugUtilsObjectTagInfoEXT&() const
+ operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const
{
- return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(this);
+ return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
}
- bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const
+ operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
+ }
+
+ bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectType == rhs.objectType )
- && ( objectHandle == rhs.objectHandle )
- && ( tagName == rhs.tagName )
- && ( tagSize == rhs.tagSize )
- && ( pTag == rhs.pTag );
+ && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
}
- bool operator!=( DebugUtilsObjectTagInfoEXT const& rhs ) const
+ bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
+ StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
public:
const void* pNext = nullptr;
- ObjectType objectType;
- uint64_t objectHandle;
- uint64_t tagName;
- size_t tagSize;
- const void* pTag;
+ Bool32 representativeFragmentTestEnable;
};
- static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
- struct DebugUtilsMessengerCallbackDataEXT
+ struct PhysicalDeviceExclusiveScissorFeaturesNV
{
- DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(),
- const char* pMessageIdName_ = nullptr,
- int32_t messageIdNumber_ = 0,
- const char* pMessage_ = nullptr,
- uint32_t queueLabelCount_ = 0,
- DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
- uint32_t cmdBufLabelCount_ = 0,
- DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
- uint32_t objectCount_ = 0,
- DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
- : flags( flags_ )
- , pMessageIdName( pMessageIdName_ )
- , messageIdNumber( messageIdNumber_ )
- , pMessage( pMessage_ )
- , queueLabelCount( queueLabelCount_ )
- , pQueueLabels( pQueueLabels_ )
- , cmdBufLabelCount( cmdBufLabelCount_ )
- , pCmdBufLabels( pCmdBufLabels_ )
- , objectCount( objectCount_ )
- , pObjects( pObjects_ )
+ PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = 0 )
+ : exclusiveScissor( exclusiveScissor_ )
{
}
- DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+ PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
}
- DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+ PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
return *this;
}
- DebugUtilsMessengerCallbackDataEXT& setPNext( const void* pNext_ )
+ PhysicalDeviceExclusiveScissorFeaturesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DebugUtilsMessengerCallbackDataEXT& setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
+ PhysicalDeviceExclusiveScissorFeaturesNV& setExclusiveScissor( Bool32 exclusiveScissor_ )
{
- flags = flags_;
+ exclusiveScissor = exclusiveScissor_;
return *this;
}
- DebugUtilsMessengerCallbackDataEXT& setPMessageIdName( const char* pMessageIdName_ )
+ operator VkPhysicalDeviceExclusiveScissorFeaturesNV const&() const
{
- pMessageIdName = pMessageIdName_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
}
- DebugUtilsMessengerCallbackDataEXT& setMessageIdNumber( int32_t messageIdNumber_ )
+ operator VkPhysicalDeviceExclusiveScissorFeaturesNV &()
{
- messageIdNumber = messageIdNumber_;
- return *this;
+ return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
}
- DebugUtilsMessengerCallbackDataEXT& setPMessage( const char* pMessage_ )
+ bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const
{
- pMessage = pMessage_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( exclusiveScissor == rhs.exclusiveScissor );
}
- DebugUtilsMessengerCallbackDataEXT& setQueueLabelCount( uint32_t queueLabelCount_ )
+ bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const
{
- queueLabelCount = queueLabelCount_;
- return *this;
+ return !operator==( rhs );
}
- DebugUtilsMessengerCallbackDataEXT& setPQueueLabels( DebugUtilsLabelEXT* pQueueLabels_ )
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
+
+ public:
+ void* pNext = nullptr;
+ Bool32 exclusiveScissor;
+ };
+ static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
+
+ struct PipelineViewportExclusiveScissorStateCreateInfoNV
+ {
+ PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
+ const Rect2D* pExclusiveScissors_ = nullptr )
+ : exclusiveScissorCount( exclusiveScissorCount_ )
+ , pExclusiveScissors( pExclusiveScissors_ )
{
- pQueueLabels = pQueueLabels_;
- return *this;
}
- DebugUtilsMessengerCallbackDataEXT& setCmdBufLabelCount( uint32_t cmdBufLabelCount_ )
+ PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
{
- cmdBufLabelCount = cmdBufLabelCount_;
- return *this;
+ memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
}
- DebugUtilsMessengerCallbackDataEXT& setPCmdBufLabels( DebugUtilsLabelEXT* pCmdBufLabels_ )
+ PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
{
- pCmdBufLabels = pCmdBufLabels_;
+ memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
+ return *this;
+ }
+ PipelineViewportExclusiveScissorStateCreateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- DebugUtilsMessengerCallbackDataEXT& setObjectCount( uint32_t objectCount_ )
+ PipelineViewportExclusiveScissorStateCreateInfoNV& setExclusiveScissorCount( uint32_t exclusiveScissorCount_ )
{
- objectCount = objectCount_;
+ exclusiveScissorCount = exclusiveScissorCount_;
return *this;
}
- DebugUtilsMessengerCallbackDataEXT& setPObjects( DebugUtilsObjectNameInfoEXT* pObjects_ )
+ PipelineViewportExclusiveScissorStateCreateInfoNV& setPExclusiveScissors( const Rect2D* pExclusiveScissors_ )
{
- pObjects = pObjects_;
+ pExclusiveScissors = pExclusiveScissors_;
return *this;
}
- operator const VkDebugUtilsMessengerCallbackDataEXT&() const
+ operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const
{
- return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(this);
+ return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
}
- bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
+ operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
+ }
+
+ bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( pMessageIdName == rhs.pMessageIdName )
- && ( messageIdNumber == rhs.messageIdNumber )
- && ( pMessage == rhs.pMessage )
- && ( queueLabelCount == rhs.queueLabelCount )
- && ( pQueueLabels == rhs.pQueueLabels )
- && ( cmdBufLabelCount == rhs.cmdBufLabelCount )
- && ( pCmdBufLabels == rhs.pCmdBufLabels )
- && ( objectCount == rhs.objectCount )
- && ( pObjects == rhs.pObjects );
+ && ( exclusiveScissorCount == rhs.exclusiveScissorCount )
+ && ( pExclusiveScissors == rhs.pExclusiveScissors );
}
- bool operator!=( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
+ bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
+ StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
public:
const void* pNext = nullptr;
- DebugUtilsMessengerCallbackDataFlagsEXT flags;
- const char* pMessageIdName;
- int32_t messageIdNumber;
- const char* pMessage;
- uint32_t queueLabelCount;
- DebugUtilsLabelEXT* pQueueLabels;
- uint32_t cmdBufLabelCount;
- DebugUtilsLabelEXT* pCmdBufLabels;
- uint32_t objectCount;
- DebugUtilsObjectNameInfoEXT* pObjects;
- };
- static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
-
- enum class QueueFlagBits
- {
- eGraphics = VK_QUEUE_GRAPHICS_BIT,
- eCompute = VK_QUEUE_COMPUTE_BIT,
- eTransfer = VK_QUEUE_TRANSFER_BIT,
- eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
- eProtected = VK_QUEUE_PROTECTED_BIT
+ uint32_t exclusiveScissorCount;
+ const Rect2D* pExclusiveScissors;
};
+ static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
- using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
-
- VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
- {
- return QueueFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
- {
- return ~( QueueFlags( bits ) );
- }
-
- template <> struct FlagTraits<QueueFlagBits>
+ struct PhysicalDeviceCornerSampledImageFeaturesNV
{
- enum
+ PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 )
+ : cornerSampledImage( cornerSampledImage_ )
{
- allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) | VkFlags(QueueFlagBits::eProtected)
- };
- };
+ }
- struct QueueFamilyProperties
- {
- operator const VkQueueFamilyProperties&() const
+ PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
{
- return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
+ memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
}
- bool operator==( QueueFamilyProperties const& rhs ) const
+ PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
{
- return ( queueFlags == rhs.queueFlags )
- && ( queueCount == rhs.queueCount )
- && ( timestampValidBits == rhs.timestampValidBits )
- && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
+ return *this;
+ }
+ PhysicalDeviceCornerSampledImageFeaturesNV& setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
}
- bool operator!=( QueueFamilyProperties const& rhs ) const
+ PhysicalDeviceCornerSampledImageFeaturesNV& setCornerSampledImage( Bool32 cornerSampledImage_ )
{
- return !operator==( rhs );
+ cornerSampledImage = cornerSampledImage_;
+ return *this;
}
- QueueFlags queueFlags;
- uint32_t queueCount;
- uint32_t timestampValidBits;
- Extent3D minImageTransferGranularity;
- };
- static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
+ operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
+ }
- struct QueueFamilyProperties2
- {
- operator const VkQueueFamilyProperties2&() const
+ operator VkPhysicalDeviceCornerSampledImageFeaturesNV &()
{
- return *reinterpret_cast<const VkQueueFamilyProperties2*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
}
- bool operator==( QueueFamilyProperties2 const& rhs ) const
+ bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( queueFamilyProperties == rhs.queueFamilyProperties );
+ && ( cornerSampledImage == rhs.cornerSampledImage );
}
- bool operator!=( QueueFamilyProperties2 const& rhs ) const
+ bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eQueueFamilyProperties2;
+ StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
public:
void* pNext = nullptr;
- QueueFamilyProperties queueFamilyProperties;
- };
- static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
-
- using QueueFamilyProperties2KHR = QueueFamilyProperties2;
-
- enum class DeviceQueueCreateFlagBits
- {
- eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
- };
-
- using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
-
- VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
- {
- return DeviceQueueCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits )
- {
- return ~( DeviceQueueCreateFlags( bits ) );
- }
-
- template <> struct FlagTraits<DeviceQueueCreateFlagBits>
- {
- enum
- {
- allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected)
- };
+ Bool32 cornerSampledImage;
};
+ static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
- struct DeviceQueueCreateInfo
+ struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
{
- DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
- uint32_t queueFamilyIndex_ = 0,
- uint32_t queueCount_ = 0,
- const float* pQueuePriorities_ = nullptr )
- : flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
- , queueCount( queueCount_ )
- , pQueuePriorities( pQueuePriorities_ )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0,
+ Bool32 computeDerivativeGroupLinear_ = 0 )
+ : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
+ , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
{
}
- DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
}
- DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
return *this;
}
- DeviceQueueCreateInfo& setPNext( const void* pNext_ )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV& setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ )
{
- queueFamilyIndex = queueFamilyIndex_;
+ computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
return *this;
}
- DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV& setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ )
{
- queueCount = queueCount_;
+ computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
return *this;
}
- DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ )
+ operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const
{
- pQueuePriorities = pQueuePriorities_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
}
- operator const VkDeviceQueueCreateInfo&() const
+ operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &()
{
- return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
}
- bool operator==( DeviceQueueCreateInfo const& rhs ) const
+ bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( queueFamilyIndex == rhs.queueFamilyIndex )
- && ( queueCount == rhs.queueCount )
- && ( pQueuePriorities == rhs.pQueuePriorities );
+ && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads )
+ && ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
}
- bool operator!=( DeviceQueueCreateInfo const& rhs ) const
+ bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceQueueCreateInfo;
+ StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
public:
- const void* pNext = nullptr;
- DeviceQueueCreateFlags flags;
- uint32_t queueFamilyIndex;
- uint32_t queueCount;
- const float* pQueuePriorities;
+ void* pNext = nullptr;
+ Bool32 computeDerivativeGroupQuads;
+ Bool32 computeDerivativeGroupLinear;
};
- static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
- struct DeviceCreateInfo
+ struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
{
- DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(),
- uint32_t queueCreateInfoCount_ = 0,
- const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
- uint32_t enabledLayerCount_ = 0,
- const char* const* ppEnabledLayerNames_ = nullptr,
- uint32_t enabledExtensionCount_ = 0,
- const char* const* ppEnabledExtensionNames_ = nullptr,
- const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
- : flags( flags_ )
- , queueCreateInfoCount( queueCreateInfoCount_ )
- , pQueueCreateInfos( pQueueCreateInfos_ )
- , enabledLayerCount( enabledLayerCount_ )
- , ppEnabledLayerNames( ppEnabledLayerNames_ )
- , enabledExtensionCount( enabledExtensionCount_ )
- , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
- , pEnabledFeatures( pEnabledFeatures_ )
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 )
+ : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
{
}
- DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
}
- DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
return *this;
}
- DeviceCreateInfo& setPNext( const void* pNext_ )
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ )
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV& setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ )
{
- flags = flags_;
+ fragmentShaderBarycentric = fragmentShaderBarycentric_;
return *this;
}
- DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ )
+ operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const
{
- queueCreateInfoCount = queueCreateInfoCount_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
}
- DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
+ operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &()
{
- pQueueCreateInfos = pQueueCreateInfos_;
- return *this;
+ return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
}
- DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
+ bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
{
- enabledLayerCount = enabledLayerCount_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
}
- DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
+ bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
{
- ppEnabledLayerNames = ppEnabledLayerNames_;
- return *this;
+ return !operator==( rhs );
}
- DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+
+ public:
+ void* pNext = nullptr;
+ Bool32 fragmentShaderBarycentric;
+ };
+ static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceShaderImageFootprintFeaturesNV
+ {
+ PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 )
+ : imageFootprint( imageFootprint_ )
{
- enabledExtensionCount = enabledExtensionCount_;
- return *this;
}
- DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
+ PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
{
- ppEnabledExtensionNames = ppEnabledExtensionNames_;
+ memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
+ }
+
+ PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
+ return *this;
+ }
+ PhysicalDeviceShaderImageFootprintFeaturesNV& setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
+ PhysicalDeviceShaderImageFootprintFeaturesNV& setImageFootprint( Bool32 imageFootprint_ )
{
- pEnabledFeatures = pEnabledFeatures_;
+ imageFootprint = imageFootprint_;
return *this;
}
- operator const VkDeviceCreateInfo&() const
+ operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const
{
- return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
}
- bool operator==( DeviceCreateInfo const& rhs ) const
+ operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
+ }
+
+ bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( queueCreateInfoCount == rhs.queueCreateInfoCount )
- && ( pQueueCreateInfos == rhs.pQueueCreateInfos )
- && ( enabledLayerCount == rhs.enabledLayerCount )
- && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
- && ( enabledExtensionCount == rhs.enabledExtensionCount )
- && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames )
- && ( pEnabledFeatures == rhs.pEnabledFeatures );
+ && ( imageFootprint == rhs.imageFootprint );
}
- bool operator!=( DeviceCreateInfo const& rhs ) const
+ bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceCreateInfo;
+ StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
public:
- const void* pNext = nullptr;
- DeviceCreateFlags flags;
- uint32_t queueCreateInfoCount;
- const DeviceQueueCreateInfo* pQueueCreateInfos;
- uint32_t enabledLayerCount;
- const char* const* ppEnabledLayerNames;
- uint32_t enabledExtensionCount;
- const char* const* ppEnabledExtensionNames;
- const PhysicalDeviceFeatures* pEnabledFeatures;
+ void* pNext = nullptr;
+ Bool32 imageFootprint;
};
- static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
- struct DeviceQueueInfo2
+ struct PhysicalDeviceShadingRateImageFeaturesNV
{
- DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
- uint32_t queueFamilyIndex_ = 0,
- uint32_t queueIndex_ = 0 )
- : flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
- , queueIndex( queueIndex_ )
+ PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0,
+ Bool32 shadingRateCoarseSampleOrder_ = 0 )
+ : shadingRateImage( shadingRateImage_ )
+ , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
{
}
- DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
+ PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
}
- DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
+ PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
return *this;
}
- DeviceQueueInfo2& setPNext( const void* pNext_ )
+ PhysicalDeviceShadingRateImageFeaturesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DeviceQueueInfo2& setFlags( DeviceQueueCreateFlags flags_ )
+ PhysicalDeviceShadingRateImageFeaturesNV& setShadingRateImage( Bool32 shadingRateImage_ )
{
- flags = flags_;
+ shadingRateImage = shadingRateImage_;
return *this;
}
- DeviceQueueInfo2& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+ PhysicalDeviceShadingRateImageFeaturesNV& setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ )
{
- queueFamilyIndex = queueFamilyIndex_;
+ shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
return *this;
}
- DeviceQueueInfo2& setQueueIndex( uint32_t queueIndex_ )
+ operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const
{
- queueIndex = queueIndex_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
}
- operator const VkDeviceQueueInfo2&() const
+ operator VkPhysicalDeviceShadingRateImageFeaturesNV &()
{
- return *reinterpret_cast<const VkDeviceQueueInfo2*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
}
- bool operator==( DeviceQueueInfo2 const& rhs ) const
+ bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( queueFamilyIndex == rhs.queueFamilyIndex )
- && ( queueIndex == rhs.queueIndex );
+ && ( shadingRateImage == rhs.shadingRateImage )
+ && ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
}
- bool operator!=( DeviceQueueInfo2 const& rhs ) const
+ bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceQueueInfo2;
+ StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
public:
- const void* pNext = nullptr;
- DeviceQueueCreateFlags flags;
- uint32_t queueFamilyIndex;
- uint32_t queueIndex;
- };
- static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
-
- enum class MemoryPropertyFlagBits
- {
- eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
- eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
- eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
- eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
- eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT
+ void* pNext = nullptr;
+ Bool32 shadingRateImage;
+ Bool32 shadingRateCoarseSampleOrder;
};
+ static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
- using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
-
- VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
- {
- return MemoryPropertyFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
- {
- return ~( MemoryPropertyFlags( bits ) );
- }
-
- template <> struct FlagTraits<MemoryPropertyFlagBits>
+ struct PhysicalDeviceShadingRateImagePropertiesNV
{
- enum
+ operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const
{
- allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected)
- };
- };
+ return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
+ }
- struct MemoryType
- {
- operator const VkMemoryType&() const
+ operator VkPhysicalDeviceShadingRateImagePropertiesNV &()
{
- return *reinterpret_cast<const VkMemoryType*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
}
- bool operator==( MemoryType const& rhs ) const
+ bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
{
- return ( propertyFlags == rhs.propertyFlags )
- && ( heapIndex == rhs.heapIndex );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( shadingRateTexelSize == rhs.shadingRateTexelSize )
+ && ( shadingRatePaletteSize == rhs.shadingRatePaletteSize )
+ && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
}
- bool operator!=( MemoryType const& rhs ) const
+ bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
{
return !operator==( rhs );
}
- MemoryPropertyFlags propertyFlags;
- uint32_t heapIndex;
- };
- static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
- enum class MemoryHeapFlagBits
- {
- eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
- eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
- eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
+ public:
+ void* pNext = nullptr;
+ Extent2D shadingRateTexelSize;
+ uint32_t shadingRatePaletteSize;
+ uint32_t shadingRateMaxCoarseSamples;
};
+ static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
- using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
-
- VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
- {
- return MemoryHeapFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
- {
- return ~( MemoryHeapFlags( bits ) );
- }
-
- template <> struct FlagTraits<MemoryHeapFlagBits>
+ struct PhysicalDeviceMeshShaderFeaturesNV
{
- enum
+ PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0,
+ Bool32 meshShader_ = 0 )
+ : taskShader( taskShader_ )
+ , meshShader( meshShader_ )
{
- allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstance)
- };
- };
+ }
- struct MemoryHeap
- {
- operator const VkMemoryHeap&() const
+ PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
{
- return *reinterpret_cast<const VkMemoryHeap*>(this);
+ memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
}
- bool operator==( MemoryHeap const& rhs ) const
+ PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
{
- return ( size == rhs.size )
- && ( flags == rhs.flags );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
+ return *this;
}
-
- bool operator!=( MemoryHeap const& rhs ) const
+ PhysicalDeviceMeshShaderFeaturesNV& setPNext( void* pNext_ )
{
- return !operator==( rhs );
+ pNext = pNext_;
+ return *this;
}
- DeviceSize size;
- MemoryHeapFlags flags;
- };
- static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
-
- struct PhysicalDeviceMemoryProperties
- {
- operator const VkPhysicalDeviceMemoryProperties&() const
+ PhysicalDeviceMeshShaderFeaturesNV& setTaskShader( Bool32 taskShader_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
+ taskShader = taskShader_;
+ return *this;
}
- bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
+ PhysicalDeviceMeshShaderFeaturesNV& setMeshShader( Bool32 meshShader_ )
{
- return ( memoryTypeCount == rhs.memoryTypeCount )
- && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
- && ( memoryHeapCount == rhs.memoryHeapCount )
- && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
+ meshShader = meshShader_;
+ return *this;
}
- bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
+ operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
}
- uint32_t memoryTypeCount;
- MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
- uint32_t memoryHeapCount;
- MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
- };
- static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
-
- struct PhysicalDeviceMemoryProperties2
- {
- operator const VkPhysicalDeviceMemoryProperties2&() const
+ operator VkPhysicalDeviceMeshShaderFeaturesNV &()
{
- return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
}
- bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const
+ bool operator==( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memoryProperties == rhs.memoryProperties );
+ && ( taskShader == rhs.taskShader )
+ && ( meshShader == rhs.meshShader );
}
- bool operator!=( PhysicalDeviceMemoryProperties2 const& rhs ) const
+ bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+ StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
public:
void* pNext = nullptr;
- PhysicalDeviceMemoryProperties memoryProperties;
- };
- static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
-
- using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
-
- enum class AccessFlagBits
- {
- eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
- eIndexRead = VK_ACCESS_INDEX_READ_BIT,
- eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
- eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
- eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
- eShaderRead = VK_ACCESS_SHADER_READ_BIT,
- eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
- eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
- eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
- eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
- eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
- eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
- eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
- eHostRead = VK_ACCESS_HOST_READ_BIT,
- eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
- eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
- eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
- eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
- eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
- eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
- eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT
- };
-
- using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
-
- VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
- {
- return AccessFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
- {
- return ~( AccessFlags( bits ) );
- }
-
- template <> struct FlagTraits<AccessFlagBits>
- {
- enum
- {
- allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT)
- };
+ Bool32 taskShader;
+ Bool32 meshShader;
};
+ static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
- struct MemoryBarrier
+ struct PhysicalDeviceMeshShaderPropertiesNV
{
- MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags() )
- : srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
+ PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0,
+ uint32_t maxTaskWorkGroupInvocations_ = 0,
+ std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0, 0, 0 } },
+ uint32_t maxTaskTotalMemorySize_ = 0,
+ uint32_t maxTaskOutputCount_ = 0,
+ uint32_t maxMeshWorkGroupInvocations_ = 0,
+ std::array<uint32_t,3> const& maxMeshWorkGroupSize_ = { { 0, 0, 0 } },
+ uint32_t maxMeshTotalMemorySize_ = 0,
+ uint32_t maxMeshOutputVertices_ = 0,
+ uint32_t maxMeshOutputPrimitives_ = 0,
+ uint32_t maxMeshMultiviewViewCount_ = 0,
+ uint32_t meshOutputPerVertexGranularity_ = 0,
+ uint32_t meshOutputPerPrimitiveGranularity_ = 0 )
+ : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
+ , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
+ , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
+ , maxTaskOutputCount( maxTaskOutputCount_ )
+ , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
+ , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
+ , maxMeshOutputVertices( maxMeshOutputVertices_ )
+ , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
+ , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
+ , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
+ , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
{
+ memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+ memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
}
- MemoryBarrier( VkMemoryBarrier const & rhs )
+ PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryBarrier ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
}
- MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
+ PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryBarrier ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
return *this;
}
- MemoryBarrier& setPNext( const void* pNext_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxDrawMeshTasksCount( uint32_t maxDrawMeshTasksCount_ )
{
- srcAccessMask = srcAccessMask_;
+ maxDrawMeshTasksCount = maxDrawMeshTasksCount_;
return *this;
}
- MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupInvocations( uint32_t maxTaskWorkGroupInvocations_ )
{
- dstAccessMask = dstAccessMask_;
+ maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations_;
return *this;
}
- operator const VkMemoryBarrier&() const
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupSize( std::array<uint32_t,3> maxTaskWorkGroupSize_ )
{
- return *reinterpret_cast<const VkMemoryBarrier*>(this);
- }
-
- bool operator==( MemoryBarrier const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask );
- }
-
- bool operator!=( MemoryBarrier const& rhs ) const
- {
- return !operator==( rhs );
+ memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+ return *this;
}
- private:
- StructureType sType = StructureType::eMemoryBarrier;
-
- public:
- const void* pNext = nullptr;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- };
- static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
-
- struct BufferMemoryBarrier
- {
- BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- uint32_t srcQueueFamilyIndex_ = 0,
- uint32_t dstQueueFamilyIndex_ = 0,
- Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0,
- DeviceSize size_ = 0 )
- : srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
- , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
- , buffer( buffer_ )
- , offset( offset_ )
- , size( size_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskTotalMemorySize( uint32_t maxTaskTotalMemorySize_ )
{
+ maxTaskTotalMemorySize = maxTaskTotalMemorySize_;
+ return *this;
}
- BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskOutputCount( uint32_t maxTaskOutputCount_ )
{
- memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
+ maxTaskOutputCount = maxTaskOutputCount_;
+ return *this;
}
- BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupInvocations( uint32_t maxMeshWorkGroupInvocations_ )
{
- memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
+ maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations_;
return *this;
}
- BufferMemoryBarrier& setPNext( const void* pNext_ )
+
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupSize( std::array<uint32_t,3> maxMeshWorkGroupSize_ )
{
- pNext = pNext_;
+ memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
return *this;
}
- BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshTotalMemorySize( uint32_t maxMeshTotalMemorySize_ )
{
- srcAccessMask = srcAccessMask_;
+ maxMeshTotalMemorySize = maxMeshTotalMemorySize_;
return *this;
}
- BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshOutputVertices( uint32_t maxMeshOutputVertices_ )
{
- dstAccessMask = dstAccessMask_;
+ maxMeshOutputVertices = maxMeshOutputVertices_;
return *this;
}
- BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshOutputPrimitives( uint32_t maxMeshOutputPrimitives_ )
{
- srcQueueFamilyIndex = srcQueueFamilyIndex_;
+ maxMeshOutputPrimitives = maxMeshOutputPrimitives_;
return *this;
}
- BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshMultiviewViewCount( uint32_t maxMeshMultiviewViewCount_ )
{
- dstQueueFamilyIndex = dstQueueFamilyIndex_;
+ maxMeshMultiviewViewCount = maxMeshMultiviewViewCount_;
return *this;
}
- BufferMemoryBarrier& setBuffer( Buffer buffer_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMeshOutputPerVertexGranularity( uint32_t meshOutputPerVertexGranularity_ )
{
- buffer = buffer_;
+ meshOutputPerVertexGranularity = meshOutputPerVertexGranularity_;
return *this;
}
- BufferMemoryBarrier& setOffset( DeviceSize offset_ )
+ PhysicalDeviceMeshShaderPropertiesNV& setMeshOutputPerPrimitiveGranularity( uint32_t meshOutputPerPrimitiveGranularity_ )
{
- offset = offset_;
+ meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity_;
return *this;
}
- BufferMemoryBarrier& setSize( DeviceSize size_ )
+ operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const
{
- size = size_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
}
- operator const VkBufferMemoryBarrier&() const
+ operator VkPhysicalDeviceMeshShaderPropertiesNV &()
{
- return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
}
- bool operator==( BufferMemoryBarrier const& rhs ) const
+ bool operator==( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
- && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
- && ( buffer == rhs.buffer )
- && ( offset == rhs.offset )
- && ( size == rhs.size );
+ && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount )
+ && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations )
+ && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize )
+ && ( maxTaskOutputCount == rhs.maxTaskOutputCount )
+ && ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations )
+ && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize )
+ && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices )
+ && ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives )
+ && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount )
+ && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity )
+ && ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
}
- bool operator!=( BufferMemoryBarrier const& rhs ) const
+ bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eBufferMemoryBarrier;
+ StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
public:
- const void* pNext = nullptr;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- Buffer buffer;
- DeviceSize offset;
- DeviceSize size;
- };
- static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
-
- enum class BufferUsageFlagBits
- {
- eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
- eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
- eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
- eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
- eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
- eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
- eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
- eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
- eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
- eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT
- };
-
- using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
-
- VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
- {
- return BufferUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
- {
- return ~( BufferUsageFlags( bits ) );
- }
-
- template <> struct FlagTraits<BufferUsageFlagBits>
- {
- enum
+ void* pNext = nullptr;
+ uint32_t maxDrawMeshTasksCount;
+ uint32_t maxTaskWorkGroupInvocations;
+ uint32_t maxTaskWorkGroupSize[3];
+ uint32_t maxTaskTotalMemorySize;
+ uint32_t maxTaskOutputCount;
+ uint32_t maxMeshWorkGroupInvocations;
+ uint32_t maxMeshWorkGroupSize[3];
+ uint32_t maxMeshTotalMemorySize;
+ uint32_t maxMeshOutputVertices;
+ uint32_t maxMeshOutputPrimitives;
+ uint32_t maxMeshMultiviewViewCount;
+ uint32_t meshOutputPerVertexGranularity;
+ uint32_t meshOutputPerPrimitiveGranularity;
+ };
+ static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" );
+
+ struct GeometryTrianglesNV
+ {
+ GeometryTrianglesNV( Buffer vertexData_ = Buffer(),
+ DeviceSize vertexOffset_ = 0,
+ uint32_t vertexCount_ = 0,
+ DeviceSize vertexStride_ = 0,
+ Format vertexFormat_ = Format::eUndefined,
+ Buffer indexData_ = Buffer(),
+ DeviceSize indexOffset_ = 0,
+ uint32_t indexCount_ = 0,
+ IndexType indexType_ = IndexType::eUint16,
+ Buffer transformData_ = Buffer(),
+ DeviceSize transformOffset_ = 0 )
+ : vertexData( vertexData_ )
+ , vertexOffset( vertexOffset_ )
+ , vertexCount( vertexCount_ )
+ , vertexStride( vertexStride_ )
+ , vertexFormat( vertexFormat_ )
+ , indexData( indexData_ )
+ , indexOffset( indexOffset_ )
+ , indexCount( indexCount_ )
+ , indexType( indexType_ )
+ , transformData( transformData_ )
+ , transformOffset( transformOffset_ )
{
- allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT)
- };
- };
-
- enum class BufferCreateFlagBits
- {
- eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
- eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
- eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
- eProtected = VK_BUFFER_CREATE_PROTECTED_BIT
- };
-
- using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
+ }
- VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
- {
- return BufferCreateFlags( bit0 ) | bit1;
- }
+ GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
+ }
- VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
- {
- return ~( BufferCreateFlags( bits ) );
- }
+ GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
+ return *this;
+ }
+ GeometryTrianglesNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- template <> struct FlagTraits<BufferCreateFlagBits>
- {
- enum
+ GeometryTrianglesNV& setVertexData( Buffer vertexData_ )
{
- allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected)
- };
- };
+ vertexData = vertexData_;
+ return *this;
+ }
- struct BufferCreateInfo
- {
- BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
- DeviceSize size_ = 0,
- BufferUsageFlags usage_ = BufferUsageFlags(),
- SharingMode sharingMode_ = SharingMode::eExclusive,
- uint32_t queueFamilyIndexCount_ = 0,
- const uint32_t* pQueueFamilyIndices_ = nullptr )
- : flags( flags_ )
- , size( size_ )
- , usage( usage_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ GeometryTrianglesNV& setVertexOffset( DeviceSize vertexOffset_ )
{
+ vertexOffset = vertexOffset_;
+ return *this;
}
- BufferCreateInfo( VkBufferCreateInfo const & rhs )
+ GeometryTrianglesNV& setVertexCount( uint32_t vertexCount_ )
{
- memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
+ vertexCount = vertexCount_;
+ return *this;
}
- BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
+ GeometryTrianglesNV& setVertexStride( DeviceSize vertexStride_ )
{
- memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
+ vertexStride = vertexStride_;
return *this;
}
- BufferCreateInfo& setPNext( const void* pNext_ )
+
+ GeometryTrianglesNV& setVertexFormat( Format vertexFormat_ )
{
- pNext = pNext_;
+ vertexFormat = vertexFormat_;
return *this;
}
- BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
+ GeometryTrianglesNV& setIndexData( Buffer indexData_ )
{
- flags = flags_;
+ indexData = indexData_;
return *this;
}
- BufferCreateInfo& setSize( DeviceSize size_ )
+ GeometryTrianglesNV& setIndexOffset( DeviceSize indexOffset_ )
{
- size = size_;
+ indexOffset = indexOffset_;
return *this;
}
- BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
+ GeometryTrianglesNV& setIndexCount( uint32_t indexCount_ )
{
- usage = usage_;
+ indexCount = indexCount_;
return *this;
}
- BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
+ GeometryTrianglesNV& setIndexType( IndexType indexType_ )
{
- sharingMode = sharingMode_;
+ indexType = indexType_;
return *this;
}
- BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ GeometryTrianglesNV& setTransformData( Buffer transformData_ )
{
- queueFamilyIndexCount = queueFamilyIndexCount_;
+ transformData = transformData_;
return *this;
}
- BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ GeometryTrianglesNV& setTransformOffset( DeviceSize transformOffset_ )
{
- pQueueFamilyIndices = pQueueFamilyIndices_;
+ transformOffset = transformOffset_;
return *this;
}
- operator const VkBufferCreateInfo&() const
+ operator VkGeometryTrianglesNV const&() const
{
- return *reinterpret_cast<const VkBufferCreateInfo*>(this);
+ return *reinterpret_cast<const VkGeometryTrianglesNV*>(this);
}
- bool operator==( BufferCreateInfo const& rhs ) const
+ operator VkGeometryTrianglesNV &()
+ {
+ return *reinterpret_cast<VkGeometryTrianglesNV*>(this);
+ }
+
+ bool operator==( GeometryTrianglesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( size == rhs.size )
- && ( usage == rhs.usage )
- && ( sharingMode == rhs.sharingMode )
- && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
- && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+ && ( vertexData == rhs.vertexData )
+ && ( vertexOffset == rhs.vertexOffset )
+ && ( vertexCount == rhs.vertexCount )
+ && ( vertexStride == rhs.vertexStride )
+ && ( vertexFormat == rhs.vertexFormat )
+ && ( indexData == rhs.indexData )
+ && ( indexOffset == rhs.indexOffset )
+ && ( indexCount == rhs.indexCount )
+ && ( indexType == rhs.indexType )
+ && ( transformData == rhs.transformData )
+ && ( transformOffset == rhs.transformOffset );
}
- bool operator!=( BufferCreateInfo const& rhs ) const
+ bool operator!=( GeometryTrianglesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eBufferCreateInfo;
+ StructureType sType = StructureType::eGeometryTrianglesNV;
public:
const void* pNext = nullptr;
- BufferCreateFlags flags;
- DeviceSize size;
- BufferUsageFlags usage;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- };
- static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
-
- enum class ShaderStageFlagBits
- {
- eVertex = VK_SHADER_STAGE_VERTEX_BIT,
- eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
- eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
- eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
- eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
- eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
- eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
- eAll = VK_SHADER_STAGE_ALL
+ Buffer vertexData;
+ DeviceSize vertexOffset;
+ uint32_t vertexCount;
+ DeviceSize vertexStride;
+ Format vertexFormat;
+ Buffer indexData;
+ DeviceSize indexOffset;
+ uint32_t indexCount;
+ IndexType indexType;
+ Buffer transformData;
+ DeviceSize transformOffset;
};
+ static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" );
- using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
-
- VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
- {
- return ShaderStageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
- {
- return ~( ShaderStageFlags( bits ) );
- }
-
- template <> struct FlagTraits<ShaderStageFlagBits>
+ struct GeometryAABBNV
{
- enum
+ GeometryAABBNV( Buffer aabbData_ = Buffer(),
+ uint32_t numAABBs_ = 0,
+ uint32_t stride_ = 0,
+ DeviceSize offset_ = 0 )
+ : aabbData( aabbData_ )
+ , numAABBs( numAABBs_ )
+ , stride( stride_ )
+ , offset( offset_ )
{
- allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll)
- };
- };
+ }
- struct DescriptorSetLayoutBinding
- {
- DescriptorSetLayoutBinding( uint32_t binding_ = 0,
- DescriptorType descriptorType_ = DescriptorType::eSampler,
- uint32_t descriptorCount_ = 0,
- ShaderStageFlags stageFlags_ = ShaderStageFlags(),
- const Sampler* pImmutableSamplers_ = nullptr )
- : binding( binding_ )
- , descriptorType( descriptorType_ )
- , descriptorCount( descriptorCount_ )
- , stageFlags( stageFlags_ )
- , pImmutableSamplers( pImmutableSamplers_ )
+ GeometryAABBNV( VkGeometryAABBNV const & rhs )
{
+ memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
}
- DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
+ GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
+ memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
+ return *this;
+ }
+ GeometryAABBNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
}
- DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
+ GeometryAABBNV& setAabbData( Buffer aabbData_ )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
+ aabbData = aabbData_;
return *this;
}
- DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
+
+ GeometryAABBNV& setNumAABBs( uint32_t numAABBs_ )
{
- binding = binding_;
+ numAABBs = numAABBs_;
return *this;
}
- DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
+ GeometryAABBNV& setStride( uint32_t stride_ )
{
- descriptorType = descriptorType_;
+ stride = stride_;
return *this;
}
- DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
+ GeometryAABBNV& setOffset( DeviceSize offset_ )
{
- descriptorCount = descriptorCount_;
+ offset = offset_;
return *this;
}
- DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
+ operator VkGeometryAABBNV const&() const
{
- stageFlags = stageFlags_;
+ return *reinterpret_cast<const VkGeometryAABBNV*>(this);
+ }
+
+ operator VkGeometryAABBNV &()
+ {
+ return *reinterpret_cast<VkGeometryAABBNV*>(this);
+ }
+
+ bool operator==( GeometryAABBNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( aabbData == rhs.aabbData )
+ && ( numAABBs == rhs.numAABBs )
+ && ( stride == rhs.stride )
+ && ( offset == rhs.offset );
+ }
+
+ bool operator!=( GeometryAABBNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eGeometryAabbNV;
+
+ public:
+ const void* pNext = nullptr;
+ Buffer aabbData;
+ uint32_t numAABBs;
+ uint32_t stride;
+ DeviceSize offset;
+ };
+ static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" );
+
+ struct GeometryDataNV
+ {
+ GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(),
+ GeometryAABBNV aabbs_ = GeometryAABBNV() )
+ : triangles( triangles_ )
+ , aabbs( aabbs_ )
+ {
+ }
+
+ GeometryDataNV( VkGeometryDataNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( GeometryDataNV ) );
+ }
+
+ GeometryDataNV& operator=( VkGeometryDataNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( GeometryDataNV ) );
+ return *this;
+ }
+ GeometryDataNV& setTriangles( GeometryTrianglesNV triangles_ )
+ {
+ triangles = triangles_;
return *this;
}
- DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
+ GeometryDataNV& setAabbs( GeometryAABBNV aabbs_ )
{
- pImmutableSamplers = pImmutableSamplers_;
+ aabbs = aabbs_;
return *this;
}
- operator const VkDescriptorSetLayoutBinding&() const
+ operator VkGeometryDataNV const&() const
{
- return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
+ return *reinterpret_cast<const VkGeometryDataNV*>(this);
}
- bool operator==( DescriptorSetLayoutBinding const& rhs ) const
+ operator VkGeometryDataNV &()
{
- return ( binding == rhs.binding )
- && ( descriptorType == rhs.descriptorType )
- && ( descriptorCount == rhs.descriptorCount )
- && ( stageFlags == rhs.stageFlags )
- && ( pImmutableSamplers == rhs.pImmutableSamplers );
+ return *reinterpret_cast<VkGeometryDataNV*>(this);
}
- bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
+ bool operator==( GeometryDataNV const& rhs ) const
+ {
+ return ( triangles == rhs.triangles )
+ && ( aabbs == rhs.aabbs );
+ }
+
+ bool operator!=( GeometryDataNV const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t binding;
- DescriptorType descriptorType;
- uint32_t descriptorCount;
- ShaderStageFlags stageFlags;
- const Sampler* pImmutableSamplers;
+ GeometryTrianglesNV triangles;
+ GeometryAABBNV aabbs;
};
- static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
+ static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
- struct PipelineShaderStageCreateInfo
+ struct BindAccelerationStructureMemoryInfoNV
{
- PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(),
- ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex,
- ShaderModule module_ = ShaderModule(),
- const char* pName_ = nullptr,
- const SpecializationInfo* pSpecializationInfo_ = nullptr )
- : flags( flags_ )
- , stage( stage_ )
- , module( module_ )
- , pName( pName_ )
- , pSpecializationInfo( pSpecializationInfo_ )
+ BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(),
+ DeviceMemory memory_ = DeviceMemory(),
+ DeviceSize memoryOffset_ = 0,
+ uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr )
+ : accelerationStructure( accelerationStructure_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , deviceIndexCount( deviceIndexCount_ )
+ , pDeviceIndices( pDeviceIndices_ )
{
}
- PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
+ BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
}
- PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
+ BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
return *this;
}
- PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
+ BindAccelerationStructureMemoryInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
+ BindAccelerationStructureMemoryInfoNV& setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
{
- flags = flags_;
+ accelerationStructure = accelerationStructure_;
return *this;
}
- PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
+ BindAccelerationStructureMemoryInfoNV& setMemory( DeviceMemory memory_ )
{
- stage = stage_;
+ memory = memory_;
return *this;
}
- PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
+ BindAccelerationStructureMemoryInfoNV& setMemoryOffset( DeviceSize memoryOffset_ )
{
- module = module_;
+ memoryOffset = memoryOffset_;
return *this;
}
- PipelineShaderStageCreateInfo& setPName( const char* pName_ )
+ BindAccelerationStructureMemoryInfoNV& setDeviceIndexCount( uint32_t deviceIndexCount_ )
{
- pName = pName_;
+ deviceIndexCount = deviceIndexCount_;
return *this;
}
- PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
+ BindAccelerationStructureMemoryInfoNV& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
{
- pSpecializationInfo = pSpecializationInfo_;
+ pDeviceIndices = pDeviceIndices_;
return *this;
}
- operator const VkPipelineShaderStageCreateInfo&() const
+ operator VkBindAccelerationStructureMemoryInfoNV const&() const
{
- return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
+ return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(this);
}
- bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
+ operator VkBindAccelerationStructureMemoryInfoNV &()
+ {
+ return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this);
+ }
+
+ bool operator==( BindAccelerationStructureMemoryInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( stage == rhs.stage )
- && ( module == rhs.module )
- && ( pName == rhs.pName )
- && ( pSpecializationInfo == rhs.pSpecializationInfo );
+ && ( accelerationStructure == rhs.accelerationStructure )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( deviceIndexCount == rhs.deviceIndexCount )
+ && ( pDeviceIndices == rhs.pDeviceIndices );
}
- bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
+ bool operator!=( BindAccelerationStructureMemoryInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
+ StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
public:
const void* pNext = nullptr;
- PipelineShaderStageCreateFlags flags;
- ShaderStageFlagBits stage;
- ShaderModule module;
- const char* pName;
- const SpecializationInfo* pSpecializationInfo;
+ AccelerationStructureNV accelerationStructure;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
};
- static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" );
- struct PushConstantRange
+ struct WriteDescriptorSetAccelerationStructureNV
{
- PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(),
- uint32_t offset_ = 0,
- uint32_t size_ = 0 )
- : stageFlags( stageFlags_ )
- , offset( offset_ )
- , size( size_ )
+ WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
+ const AccelerationStructureNV* pAccelerationStructures_ = nullptr )
+ : accelerationStructureCount( accelerationStructureCount_ )
+ , pAccelerationStructures( pAccelerationStructures_ )
{
}
- PushConstantRange( VkPushConstantRange const & rhs )
+ WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PushConstantRange ) );
+ memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
}
- PushConstantRange& operator=( VkPushConstantRange const & rhs )
+ WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PushConstantRange ) );
+ memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
return *this;
}
- PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
+ WriteDescriptorSetAccelerationStructureNV& setPNext( const void* pNext_ )
{
- stageFlags = stageFlags_;
+ pNext = pNext_;
return *this;
}
- PushConstantRange& setOffset( uint32_t offset_ )
+ WriteDescriptorSetAccelerationStructureNV& setAccelerationStructureCount( uint32_t accelerationStructureCount_ )
{
- offset = offset_;
+ accelerationStructureCount = accelerationStructureCount_;
return *this;
}
- PushConstantRange& setSize( uint32_t size_ )
+ WriteDescriptorSetAccelerationStructureNV& setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ )
{
- size = size_;
+ pAccelerationStructures = pAccelerationStructures_;
return *this;
}
- operator const VkPushConstantRange&() const
+ operator VkWriteDescriptorSetAccelerationStructureNV const&() const
{
- return *reinterpret_cast<const VkPushConstantRange*>(this);
+ return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(this);
}
- bool operator==( PushConstantRange const& rhs ) const
+ operator VkWriteDescriptorSetAccelerationStructureNV &()
{
- return ( stageFlags == rhs.stageFlags )
- && ( offset == rhs.offset )
- && ( size == rhs.size );
+ return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this);
}
- bool operator!=( PushConstantRange const& rhs ) const
+ bool operator==( WriteDescriptorSetAccelerationStructureNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( accelerationStructureCount == rhs.accelerationStructureCount )
+ && ( pAccelerationStructures == rhs.pAccelerationStructures );
+ }
+
+ bool operator!=( WriteDescriptorSetAccelerationStructureNV const& rhs ) const
{
return !operator==( rhs );
}
- ShaderStageFlags stageFlags;
- uint32_t offset;
- uint32_t size;
+ private:
+ StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t accelerationStructureCount;
+ const AccelerationStructureNV* pAccelerationStructures;
};
- static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
+ static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" );
- struct PipelineLayoutCreateInfo
+ struct PhysicalDeviceRayTracingPropertiesNV
{
- PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(),
- uint32_t setLayoutCount_ = 0,
- const DescriptorSetLayout* pSetLayouts_ = nullptr,
- uint32_t pushConstantRangeCount_ = 0,
- const PushConstantRange* pPushConstantRanges_ = nullptr )
- : flags( flags_ )
- , setLayoutCount( setLayoutCount_ )
- , pSetLayouts( pSetLayouts_ )
- , pushConstantRangeCount( pushConstantRangeCount_ )
- , pPushConstantRanges( pPushConstantRanges_ )
+ PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0,
+ uint32_t maxRecursionDepth_ = 0,
+ uint32_t maxShaderGroupStride_ = 0,
+ uint32_t shaderGroupBaseAlignment_ = 0,
+ uint64_t maxGeometryCount_ = 0,
+ uint64_t maxInstanceCount_ = 0,
+ uint64_t maxTriangleCount_ = 0,
+ uint32_t maxDescriptorSetAccelerationStructures_ = 0 )
+ : shaderGroupHandleSize( shaderGroupHandleSize_ )
+ , maxRecursionDepth( maxRecursionDepth_ )
+ , maxShaderGroupStride( maxShaderGroupStride_ )
+ , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ )
+ , maxGeometryCount( maxGeometryCount_ )
+ , maxInstanceCount( maxInstanceCount_ )
+ , maxTriangleCount( maxTriangleCount_ )
+ , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
{
}
- PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
+ PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
}
- PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
+ PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
return *this;
}
- PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
+ PhysicalDeviceRayTracingPropertiesNV& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
+ PhysicalDeviceRayTracingPropertiesNV& setShaderGroupHandleSize( uint32_t shaderGroupHandleSize_ )
{
- flags = flags_;
+ shaderGroupHandleSize = shaderGroupHandleSize_;
return *this;
}
- PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
+ PhysicalDeviceRayTracingPropertiesNV& setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
{
- setLayoutCount = setLayoutCount_;
+ maxRecursionDepth = maxRecursionDepth_;
return *this;
}
- PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+ PhysicalDeviceRayTracingPropertiesNV& setMaxShaderGroupStride( uint32_t maxShaderGroupStride_ )
{
- pSetLayouts = pSetLayouts_;
+ maxShaderGroupStride = maxShaderGroupStride_;
return *this;
}
- PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
+ PhysicalDeviceRayTracingPropertiesNV& setShaderGroupBaseAlignment( uint32_t shaderGroupBaseAlignment_ )
{
- pushConstantRangeCount = pushConstantRangeCount_;
+ shaderGroupBaseAlignment = shaderGroupBaseAlignment_;
return *this;
}
- PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+ PhysicalDeviceRayTracingPropertiesNV& setMaxGeometryCount( uint64_t maxGeometryCount_ )
{
- pPushConstantRanges = pPushConstantRanges_;
+ maxGeometryCount = maxGeometryCount_;
return *this;
}
- operator const VkPipelineLayoutCreateInfo&() const
+ PhysicalDeviceRayTracingPropertiesNV& setMaxInstanceCount( uint64_t maxInstanceCount_ )
{
- return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
+ maxInstanceCount = maxInstanceCount_;
+ return *this;
}
- bool operator==( PipelineLayoutCreateInfo const& rhs ) const
+ PhysicalDeviceRayTracingPropertiesNV& setMaxTriangleCount( uint64_t maxTriangleCount_ )
+ {
+ maxTriangleCount = maxTriangleCount_;
+ return *this;
+ }
+
+ PhysicalDeviceRayTracingPropertiesNV& setMaxDescriptorSetAccelerationStructures( uint32_t maxDescriptorSetAccelerationStructures_ )
+ {
+ maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceRayTracingPropertiesNV const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(this);
+ }
+
+ operator VkPhysicalDeviceRayTracingPropertiesNV &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this);
+ }
+
+ bool operator==( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( setLayoutCount == rhs.setLayoutCount )
- && ( pSetLayouts == rhs.pSetLayouts )
- && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
- && ( pPushConstantRanges == rhs.pPushConstantRanges );
+ && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize )
+ && ( maxRecursionDepth == rhs.maxRecursionDepth )
+ && ( maxShaderGroupStride == rhs.maxShaderGroupStride )
+ && ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment )
+ && ( maxGeometryCount == rhs.maxGeometryCount )
+ && ( maxInstanceCount == rhs.maxInstanceCount )
+ && ( maxTriangleCount == rhs.maxTriangleCount )
+ && ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures );
}
- bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
+ bool operator!=( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineLayoutCreateInfo;
+ StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
public:
- const void* pNext = nullptr;
- PipelineLayoutCreateFlags flags;
- uint32_t setLayoutCount;
- const DescriptorSetLayout* pSetLayouts;
- uint32_t pushConstantRangeCount;
- const PushConstantRange* pPushConstantRanges;
- };
- static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
-
- struct ShaderStatisticsInfoAMD
- {
- operator const VkShaderStatisticsInfoAMD&() const
+ void* pNext = nullptr;
+ uint32_t shaderGroupHandleSize;
+ uint32_t maxRecursionDepth;
+ uint32_t maxShaderGroupStride;
+ uint32_t shaderGroupBaseAlignment;
+ uint64_t maxGeometryCount;
+ uint64_t maxInstanceCount;
+ uint64_t maxTriangleCount;
+ uint32_t maxDescriptorSetAccelerationStructures;
+ };
+ static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceImageDrmFormatModifierInfoEXT
+ {
+ PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
+ SharingMode sharingMode_ = SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr )
+ : drmFormatModifier( drmFormatModifier_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
{
- return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
}
- bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
+ PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
{
- return ( shaderStageMask == rhs.shaderStageMask )
- && ( resourceUsage == rhs.resourceUsage )
- && ( numPhysicalVgprs == rhs.numPhysicalVgprs )
- && ( numPhysicalSgprs == rhs.numPhysicalSgprs )
- && ( numAvailableVgprs == rhs.numAvailableVgprs )
- && ( numAvailableSgprs == rhs.numAvailableSgprs )
- && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
}
- bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
+ return *this;
+ }
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
}
- ShaderStageFlags shaderStageMask;
- ShaderResourceUsageAMD resourceUsage;
- uint32_t numPhysicalVgprs;
- uint32_t numPhysicalSgprs;
- uint32_t numAvailableVgprs;
- uint32_t numAvailableSgprs;
- uint32_t computeWorkGroupSize[3];
- };
- static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
-
- enum class ImageUsageFlagBits
- {
- eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
- eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
- eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
- eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
- eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
- eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
- eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
- eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
- };
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& setDrmFormatModifier( uint64_t drmFormatModifier_ )
+ {
+ drmFormatModifier = drmFormatModifier_;
+ return *this;
+ }
- using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& setSharingMode( SharingMode sharingMode_ )
+ {
+ sharingMode = sharingMode_;
+ return *this;
+ }
- VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
- {
- return ImageUsageFlags( bit0 ) | bit1;
- }
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ {
+ queueFamilyIndexCount = queueFamilyIndexCount_;
+ return *this;
+ }
- VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
- {
- return ~( ImageUsageFlags( bits ) );
- }
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ {
+ pQueueFamilyIndices = pQueueFamilyIndices_;
+ return *this;
+ }
- template <> struct FlagTraits<ImageUsageFlagBits>
- {
- enum
+ operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const&() const
{
- allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment)
- };
- };
+ return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
+ }
- struct SharedPresentSurfaceCapabilitiesKHR
- {
- operator const VkSharedPresentSurfaceCapabilitiesKHR&() const
+ operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &()
{
- return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
}
- bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
+ bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
+ && ( drmFormatModifier == rhs.drmFormatModifier )
+ && ( sharingMode == rhs.sharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
}
- bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
+ bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+ StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
public:
- void* pNext = nullptr;
- ImageUsageFlags sharedPresentSupportedUsageFlags;
+ const void* pNext = nullptr;
+ uint64_t drmFormatModifier;
+ SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
};
- static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" );
- struct ImageViewUsageCreateInfo
+ struct ImageDrmFormatModifierListCreateInfoEXT
{
- ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() )
- : usage( usage_ )
+ ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
+ const uint64_t* pDrmFormatModifiers_ = nullptr )
+ : drmFormatModifierCount( drmFormatModifierCount_ )
+ , pDrmFormatModifiers( pDrmFormatModifiers_ )
{
}
- ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
+ ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
}
- ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
+ ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
return *this;
}
- ImageViewUsageCreateInfo& setPNext( const void* pNext_ )
+ ImageDrmFormatModifierListCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageViewUsageCreateInfo& setUsage( ImageUsageFlags usage_ )
+ ImageDrmFormatModifierListCreateInfoEXT& setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ )
{
- usage = usage_;
+ drmFormatModifierCount = drmFormatModifierCount_;
return *this;
}
- operator const VkImageViewUsageCreateInfo&() const
+ ImageDrmFormatModifierListCreateInfoEXT& setPDrmFormatModifiers( const uint64_t* pDrmFormatModifiers_ )
{
- return *reinterpret_cast<const VkImageViewUsageCreateInfo*>(this);
+ pDrmFormatModifiers = pDrmFormatModifiers_;
+ return *this;
}
- bool operator==( ImageViewUsageCreateInfo const& rhs ) const
+ operator VkImageDrmFormatModifierListCreateInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(this);
+ }
+
+ operator VkImageDrmFormatModifierListCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this);
+ }
+
+ bool operator==( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( usage == rhs.usage );
+ && ( drmFormatModifierCount == rhs.drmFormatModifierCount )
+ && ( pDrmFormatModifiers == rhs.pDrmFormatModifiers );
}
- bool operator!=( ImageViewUsageCreateInfo const& rhs ) const
+ bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImageViewUsageCreateInfo;
+ StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
public:
const void* pNext = nullptr;
- ImageUsageFlags usage;
- };
- static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
-
- using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
-
- enum class ImageCreateFlagBits
- {
- eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
- eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
- eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
- eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
- eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
- eAlias = VK_IMAGE_CREATE_ALIAS_BIT,
- eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT,
- eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
- eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
- e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
- e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
- eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
- eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
- eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
- eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
- eProtected = VK_IMAGE_CREATE_PROTECTED_BIT,
- eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
- eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT,
- eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT
- };
-
- using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
-
- VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
- {
- return ImageCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
- {
- return ~( ImageCreateFlags( bits ) );
- }
-
- template <> struct FlagTraits<ImageCreateFlagBits>
- {
- enum
- {
- allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT)
- };
+ uint32_t drmFormatModifierCount;
+ const uint64_t* pDrmFormatModifiers;
};
+ static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
- struct PhysicalDeviceImageFormatInfo2
+ struct ImageDrmFormatModifierExplicitCreateInfoEXT
{
- PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined,
- ImageType type_ = ImageType::e1D,
- ImageTiling tiling_ = ImageTiling::eOptimal,
- ImageUsageFlags usage_ = ImageUsageFlags(),
- ImageCreateFlags flags_ = ImageCreateFlags() )
- : format( format_ )
- , type( type_ )
- , tiling( tiling_ )
- , usage( usage_ )
- , flags( flags_ )
+ ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
+ uint32_t drmFormatModifierPlaneCount_ = 0,
+ const SubresourceLayout* pPlaneLayouts_ = nullptr )
+ : drmFormatModifier( drmFormatModifier_ )
+ , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
+ , pPlaneLayouts( pPlaneLayouts_ )
{
}
- PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
+ ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
+ memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
}
- PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs )
+ ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
+ memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
return *this;
}
- PhysicalDeviceImageFormatInfo2& setPNext( const void* pNext_ )
+ ImageDrmFormatModifierExplicitCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceImageFormatInfo2& setFormat( Format format_ )
- {
- format = format_;
- return *this;
- }
-
- PhysicalDeviceImageFormatInfo2& setType( ImageType type_ )
+ ImageDrmFormatModifierExplicitCreateInfoEXT& setDrmFormatModifier( uint64_t drmFormatModifier_ )
{
- type = type_;
+ drmFormatModifier = drmFormatModifier_;
return *this;
}
- PhysicalDeviceImageFormatInfo2& setTiling( ImageTiling tiling_ )
+ ImageDrmFormatModifierExplicitCreateInfoEXT& setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ )
{
- tiling = tiling_;
+ drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_;
return *this;
}
- PhysicalDeviceImageFormatInfo2& setUsage( ImageUsageFlags usage_ )
+ ImageDrmFormatModifierExplicitCreateInfoEXT& setPPlaneLayouts( const SubresourceLayout* pPlaneLayouts_ )
{
- usage = usage_;
+ pPlaneLayouts = pPlaneLayouts_;
return *this;
}
- PhysicalDeviceImageFormatInfo2& setFlags( ImageCreateFlags flags_ )
+ operator VkImageDrmFormatModifierExplicitCreateInfoEXT const&() const
{
- flags = flags_;
- return *this;
+ return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
}
- operator const VkPhysicalDeviceImageFormatInfo2&() const
+ operator VkImageDrmFormatModifierExplicitCreateInfoEXT &()
{
- return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(this);
+ return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
}
- bool operator==( PhysicalDeviceImageFormatInfo2 const& rhs ) const
+ bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( format == rhs.format )
- && ( type == rhs.type )
- && ( tiling == rhs.tiling )
- && ( usage == rhs.usage )
- && ( flags == rhs.flags );
+ && ( drmFormatModifier == rhs.drmFormatModifier )
+ && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount )
+ && ( pPlaneLayouts == rhs.pPlaneLayouts );
}
- bool operator!=( PhysicalDeviceImageFormatInfo2 const& rhs ) const
+ bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
+ StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
public:
const void* pNext = nullptr;
- Format format;
- ImageType type;
- ImageTiling tiling;
- ImageUsageFlags usage;
- ImageCreateFlags flags;
- };
- static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" );
-
- using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
-
- enum class PipelineCreateFlagBits
- {
- eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
- eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
- eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
- eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
- eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
- eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
- eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE
+ uint64_t drmFormatModifier;
+ uint32_t drmFormatModifierPlaneCount;
+ const SubresourceLayout* pPlaneLayouts;
};
+ static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" );
- using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
-
- VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
- {
- return PipelineCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
- {
- return ~( PipelineCreateFlags( bits ) );
- }
-
- template <> struct FlagTraits<PipelineCreateFlagBits>
+ struct ImageDrmFormatModifierPropertiesEXT
{
- enum
+ operator VkImageDrmFormatModifierPropertiesEXT const&() const
{
- allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase)
- };
- };
+ return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(this);
+ }
- struct ComputePipelineCreateInfo
- {
- ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
- PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(),
- PipelineLayout layout_ = PipelineLayout(),
- Pipeline basePipelineHandle_ = Pipeline(),
- int32_t basePipelineIndex_ = 0 )
- : flags( flags_ )
- , stage( stage_ )
- , layout( layout_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
+ operator VkImageDrmFormatModifierPropertiesEXT &()
{
+ return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this);
}
- ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
+ bool operator==( ImageDrmFormatModifierPropertiesEXT const& rhs ) const
{
- memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( drmFormatModifier == rhs.drmFormatModifier );
}
- ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
+ bool operator!=( ImageDrmFormatModifierPropertiesEXT const& rhs ) const
{
- memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
- return *this;
+ return !operator==( rhs );
}
- ComputePipelineCreateInfo& setPNext( const void* pNext_ )
+
+ private:
+ StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+
+ public:
+ void* pNext = nullptr;
+ uint64_t drmFormatModifier;
+ };
+ static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
+
+ enum class SubpassContents
+ {
+ eInline = VK_SUBPASS_CONTENTS_INLINE,
+ eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+ };
+
+ struct SubpassBeginInfoKHR
+ {
+ SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
+ : contents( contents_ )
{
- pNext = pNext_;
- return *this;
}
- ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
+ SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
{
- flags = flags_;
- return *this;
+ memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
}
- ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
+ SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
{
- stage = stage_;
+ memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
return *this;
}
-
- ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
+ SubpassBeginInfoKHR& setPNext( const void* pNext_ )
{
- layout = layout_;
+ pNext = pNext_;
return *this;
}
- ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ SubpassBeginInfoKHR& setContents( SubpassContents contents_ )
{
- basePipelineHandle = basePipelineHandle_;
+ contents = contents_;
return *this;
}
- ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
+ operator VkSubpassBeginInfoKHR const&() const
{
- basePipelineIndex = basePipelineIndex_;
- return *this;
+ return *reinterpret_cast<const VkSubpassBeginInfoKHR*>(this);
}
- operator const VkComputePipelineCreateInfo&() const
+ operator VkSubpassBeginInfoKHR &()
{
- return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
+ return *reinterpret_cast<VkSubpassBeginInfoKHR*>(this);
}
- bool operator==( ComputePipelineCreateInfo const& rhs ) const
+ bool operator==( SubpassBeginInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( stage == rhs.stage )
- && ( layout == rhs.layout )
- && ( basePipelineHandle == rhs.basePipelineHandle )
- && ( basePipelineIndex == rhs.basePipelineIndex );
+ && ( contents == rhs.contents );
}
- bool operator!=( ComputePipelineCreateInfo const& rhs ) const
+ bool operator!=( SubpassBeginInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eComputePipelineCreateInfo;
+ StructureType sType = StructureType::eSubpassBeginInfoKHR;
public:
const void* pNext = nullptr;
- PipelineCreateFlags flags;
- PipelineShaderStageCreateInfo stage;
- PipelineLayout layout;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
- };
- static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
-
- enum class ColorComponentFlagBits
- {
- eR = VK_COLOR_COMPONENT_R_BIT,
- eG = VK_COLOR_COMPONENT_G_BIT,
- eB = VK_COLOR_COMPONENT_B_BIT,
- eA = VK_COLOR_COMPONENT_A_BIT
- };
-
- using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
-
- VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
- {
- return ColorComponentFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
- {
- return ~( ColorComponentFlags( bits ) );
- }
-
- template <> struct FlagTraits<ColorComponentFlagBits>
- {
- enum
- {
- allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
- };
+ SubpassContents contents;
};
+ static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
- struct PipelineColorBlendAttachmentState
+ struct PresentInfoKHR
{
- PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0,
- BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
- BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
- BlendOp colorBlendOp_ = BlendOp::eAdd,
- BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
- BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
- BlendOp alphaBlendOp_ = BlendOp::eAdd,
- ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
- : blendEnable( blendEnable_ )
- , srcColorBlendFactor( srcColorBlendFactor_ )
- , dstColorBlendFactor( dstColorBlendFactor_ )
- , colorBlendOp( colorBlendOp_ )
- , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
- , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
- , alphaBlendOp( alphaBlendOp_ )
- , colorWriteMask( colorWriteMask_ )
+ PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
+ const Semaphore* pWaitSemaphores_ = nullptr,
+ uint32_t swapchainCount_ = 0,
+ const SwapchainKHR* pSwapchains_ = nullptr,
+ const uint32_t* pImageIndices_ = nullptr,
+ Result* pResults_ = nullptr )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , swapchainCount( swapchainCount_ )
+ , pSwapchains( pSwapchains_ )
+ , pImageIndices( pImageIndices_ )
+ , pResults( pResults_ )
{
}
- PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
+ PresentInfoKHR( VkPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+ memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
}
- PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
+ PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+ memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
return *this;
}
- PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
+ PresentInfoKHR& setPNext( const void* pNext_ )
{
- blendEnable = blendEnable_;
+ pNext = pNext_;
return *this;
}
- PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
+ PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
{
- srcColorBlendFactor = srcColorBlendFactor_;
+ waitSemaphoreCount = waitSemaphoreCount_;
return *this;
}
- PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
+ PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
{
- dstColorBlendFactor = dstColorBlendFactor_;
+ pWaitSemaphores = pWaitSemaphores_;
return *this;
}
- PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
+ PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
{
- colorBlendOp = colorBlendOp_;
+ swapchainCount = swapchainCount_;
return *this;
}
- PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
+ PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
{
- srcAlphaBlendFactor = srcAlphaBlendFactor_;
+ pSwapchains = pSwapchains_;
return *this;
}
- PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
+ PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
{
- dstAlphaBlendFactor = dstAlphaBlendFactor_;
+ pImageIndices = pImageIndices_;
return *this;
}
- PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
+ PresentInfoKHR& setPResults( Result* pResults_ )
{
- alphaBlendOp = alphaBlendOp_;
+ pResults = pResults_;
return *this;
}
- PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
+ operator VkPresentInfoKHR const&() const
{
- colorWriteMask = colorWriteMask_;
- return *this;
+ return *reinterpret_cast<const VkPresentInfoKHR*>(this);
}
- operator const VkPipelineColorBlendAttachmentState&() const
+ operator VkPresentInfoKHR &()
{
- return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
+ return *reinterpret_cast<VkPresentInfoKHR*>(this);
}
- bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
+ bool operator==( PresentInfoKHR const& rhs ) const
{
- return ( blendEnable == rhs.blendEnable )
- && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
- && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
- && ( colorBlendOp == rhs.colorBlendOp )
- && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
- && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
- && ( alphaBlendOp == rhs.alphaBlendOp )
- && ( colorWriteMask == rhs.colorWriteMask );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+ && ( pWaitSemaphores == rhs.pWaitSemaphores )
+ && ( swapchainCount == rhs.swapchainCount )
+ && ( pSwapchains == rhs.pSwapchains )
+ && ( pImageIndices == rhs.pImageIndices )
+ && ( pResults == rhs.pResults );
}
- bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
+ bool operator!=( PresentInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
- Bool32 blendEnable;
- BlendFactor srcColorBlendFactor;
- BlendFactor dstColorBlendFactor;
- BlendOp colorBlendOp;
- BlendFactor srcAlphaBlendFactor;
- BlendFactor dstAlphaBlendFactor;
- BlendOp alphaBlendOp;
- ColorComponentFlags colorWriteMask;
+ private:
+ StructureType sType = StructureType::ePresentInfoKHR;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreCount;
+ const Semaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ const SwapchainKHR* pSwapchains;
+ const uint32_t* pImageIndices;
+ Result* pResults;
};
- static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
- struct PipelineColorBlendStateCreateInfo
+ enum class DynamicState
{
- PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(),
- Bool32 logicOpEnable_ = 0,
- LogicOp logicOp_ = LogicOp::eClear,
- uint32_t attachmentCount_ = 0,
- const PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
- std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
+ eViewport = VK_DYNAMIC_STATE_VIEWPORT,
+ eScissor = VK_DYNAMIC_STATE_SCISSOR,
+ eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
+ eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
+ eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+ eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+ eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+ eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+ eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+ eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
+ eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
+ eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
+ eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
+ eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
+ eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
+ };
+
+ struct PipelineDynamicStateCreateInfo
+ {
+ PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
+ uint32_t dynamicStateCount_ = 0,
+ const DynamicState* pDynamicStates_ = nullptr )
: flags( flags_ )
- , logicOpEnable( logicOpEnable_ )
- , logicOp( logicOp_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
+ , dynamicStateCount( dynamicStateCount_ )
+ , pDynamicStates( pDynamicStates_ )
{
- memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
}
- PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
+ PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
}
- PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
+ PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
return *this;
}
- PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
+ PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
+ PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
- {
- logicOpEnable = logicOpEnable_;
- return *this;
- }
-
- PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
- {
- logicOp = logicOp_;
- return *this;
- }
-
- PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
+ PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
{
- attachmentCount = attachmentCount_;
+ dynamicStateCount = dynamicStateCount_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
+ PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
{
- pAttachments = pAttachments_;
+ pDynamicStates = pDynamicStates_;
return *this;
}
- PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
+ operator VkPipelineDynamicStateCreateInfo const&() const
{
- memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
- return *this;
+ return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
}
- operator const VkPipelineColorBlendStateCreateInfo&() const
+ operator VkPipelineDynamicStateCreateInfo &()
{
- return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
+ return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this);
}
- bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
+ bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( logicOpEnable == rhs.logicOpEnable )
- && ( logicOp == rhs.logicOp )
- && ( attachmentCount == rhs.attachmentCount )
- && ( pAttachments == rhs.pAttachments )
- && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
+ && ( dynamicStateCount == rhs.dynamicStateCount )
+ && ( pDynamicStates == rhs.pDynamicStates );
}
- bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
+ bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
+ StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
public:
const void* pNext = nullptr;
- PipelineColorBlendStateCreateFlags flags;
- Bool32 logicOpEnable;
- LogicOp logicOp;
- uint32_t attachmentCount;
- const PipelineColorBlendAttachmentState* pAttachments;
- float blendConstants[4];
- };
- static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
-
- enum class FenceCreateFlagBits
- {
- eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
+ PipelineDynamicStateCreateFlags flags;
+ uint32_t dynamicStateCount;
+ const DynamicState* pDynamicStates;
};
+ static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
- using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
-
- VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
- {
- return FenceCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
- {
- return ~( FenceCreateFlags( bits ) );
- }
-
- template <> struct FlagTraits<FenceCreateFlagBits>
+ enum class DescriptorUpdateTemplateType
{
- enum
- {
- allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
- };
+ eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+ eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+ ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
};
- struct FenceCreateInfo
+ struct DescriptorUpdateTemplateCreateInfo
{
- FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
+ DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
+ uint32_t descriptorUpdateEntryCount_ = 0,
+ const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+ DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
+ DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
+ PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+ PipelineLayout pipelineLayout_ = PipelineLayout(),
+ uint32_t set_ = 0 )
: flags( flags_ )
+ , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+ , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+ , templateType( templateType_ )
+ , descriptorSetLayout( descriptorSetLayout_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , pipelineLayout( pipelineLayout_ )
+ , set( set_ )
{
}
- FenceCreateInfo( VkFenceCreateInfo const & rhs )
+ DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
}
- FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
+ DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
return *this;
}
- FenceCreateInfo& setPNext( const void* pNext_ )
+ DescriptorUpdateTemplateCreateInfo& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
+ DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- operator const VkFenceCreateInfo&() const
+ DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
{
- return *reinterpret_cast<const VkFenceCreateInfo*>(this);
+ descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
+ return *this;
}
- bool operator==( FenceCreateInfo const& rhs ) const
+ DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( flags == rhs.flags );
+ pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
+ return *this;
}
- bool operator!=( FenceCreateInfo const& rhs ) const
+ DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ )
{
- return !operator==( rhs );
+ templateType = templateType_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eFenceCreateInfo;
-
- public:
- const void* pNext = nullptr;
- FenceCreateFlags flags;
- };
- static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
-
- enum class FormatFeatureFlagBits
- {
- eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
- eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
- eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
- eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
- eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
- eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
- eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
- eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
- eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
- eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
- eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
- eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
- eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
- eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
- eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
- eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
- eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
- eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
- eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
- eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
- eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
- eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
- eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
- eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
- eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
- eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
- eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
- eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT,
- eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
- eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
- eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
- eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
- eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT
- };
-
- using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
-
- VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
- {
- return FormatFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
- {
- return ~( FormatFeatureFlags( bits ) );
- }
-
- template <> struct FlagTraits<FormatFeatureFlagBits>
- {
- enum
+ DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
{
- allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT)
- };
- };
+ descriptorSetLayout = descriptorSetLayout_;
+ return *this;
+ }
- struct FormatProperties
- {
- operator const VkFormatProperties&() const
+ DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- return *reinterpret_cast<const VkFormatProperties*>(this);
+ pipelineBindPoint = pipelineBindPoint_;
+ return *this;
}
- bool operator==( FormatProperties const& rhs ) const
+ DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ )
{
- return ( linearTilingFeatures == rhs.linearTilingFeatures )
- && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
- && ( bufferFeatures == rhs.bufferFeatures );
+ pipelineLayout = pipelineLayout_;
+ return *this;
}
- bool operator!=( FormatProperties const& rhs ) const
+ DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ )
{
- return !operator==( rhs );
+ set = set_;
+ return *this;
}
- FormatFeatureFlags linearTilingFeatures;
- FormatFeatureFlags optimalTilingFeatures;
- FormatFeatureFlags bufferFeatures;
- };
- static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
+ operator VkDescriptorUpdateTemplateCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(this);
+ }
- struct FormatProperties2
- {
- operator const VkFormatProperties2&() const
+ operator VkDescriptorUpdateTemplateCreateInfo &()
{
- return *reinterpret_cast<const VkFormatProperties2*>(this);
+ return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this);
}
- bool operator==( FormatProperties2 const& rhs ) const
+ bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( formatProperties == rhs.formatProperties );
+ && ( flags == rhs.flags )
+ && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
+ && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
+ && ( templateType == rhs.templateType )
+ && ( descriptorSetLayout == rhs.descriptorSetLayout )
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( pipelineLayout == rhs.pipelineLayout )
+ && ( set == rhs.set );
}
- bool operator!=( FormatProperties2 const& rhs ) const
+ bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eFormatProperties2;
+ StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
public:
void* pNext = nullptr;
- FormatProperties formatProperties;
- };
- static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
-
- using FormatProperties2KHR = FormatProperties2;
-
- enum class QueryControlFlagBits
- {
- ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
- };
-
- using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
-
- VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
- {
- return QueryControlFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
- {
- return ~( QueryControlFlags( bits ) );
- }
-
- template <> struct FlagTraits<QueryControlFlagBits>
- {
- enum
- {
- allFlags = VkFlags(QueryControlFlagBits::ePrecise)
- };
- };
-
- enum class QueryResultFlagBits
- {
- e64 = VK_QUERY_RESULT_64_BIT,
- eWait = VK_QUERY_RESULT_WAIT_BIT,
- eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
- ePartial = VK_QUERY_RESULT_PARTIAL_BIT
- };
-
- using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
-
- VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
- {
- return QueryResultFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
- {
- return ~( QueryResultFlags( bits ) );
- }
-
- template <> struct FlagTraits<QueryResultFlagBits>
- {
- enum
- {
- allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
- };
- };
-
- enum class CommandBufferUsageFlagBits
- {
- eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
- eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
- eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
- };
-
- using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
-
- VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
- {
- return CommandBufferUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
- {
- return ~( CommandBufferUsageFlags( bits ) );
- }
-
- template <> struct FlagTraits<CommandBufferUsageFlagBits>
- {
- enum
- {
- allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
- };
- };
-
- enum class QueryPipelineStatisticFlagBits
- {
- eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
- eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
- eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
- eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
- eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
- eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
- eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
- eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
- eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
- eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
- eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
+ DescriptorUpdateTemplateCreateFlags flags;
+ uint32_t descriptorUpdateEntryCount;
+ const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
+ DescriptorUpdateTemplateType templateType;
+ DescriptorSetLayout descriptorSetLayout;
+ PipelineBindPoint pipelineBindPoint;
+ PipelineLayout pipelineLayout;
+ uint32_t set;
};
+ static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
- using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
-
- VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
- {
- return QueryPipelineStatisticFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
- {
- return ~( QueryPipelineStatisticFlags( bits ) );
- }
+ using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
- template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
+ enum class ObjectType
{
- enum
- {
- allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
- };
+ eUnknown = VK_OBJECT_TYPE_UNKNOWN,
+ eInstance = VK_OBJECT_TYPE_INSTANCE,
+ ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
+ eDevice = VK_OBJECT_TYPE_DEVICE,
+ eQueue = VK_OBJECT_TYPE_QUEUE,
+ eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
+ eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
+ eFence = VK_OBJECT_TYPE_FENCE,
+ eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
+ eBuffer = VK_OBJECT_TYPE_BUFFER,
+ eImage = VK_OBJECT_TYPE_IMAGE,
+ eEvent = VK_OBJECT_TYPE_EVENT,
+ eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
+ eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
+ eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
+ eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
+ ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
+ ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
+ eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
+ ePipeline = VK_OBJECT_TYPE_PIPELINE,
+ eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+ eSampler = VK_OBJECT_TYPE_SAMPLER,
+ eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+ eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
+ eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
+ eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
+ eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+ eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+ eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+ eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+ eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
+ eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
+ eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
+ eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
+ eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
+ eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
+ eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
+ eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
+ eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT,
+ eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV
};
- struct CommandBufferInheritanceInfo
+ struct DebugUtilsObjectNameInfoEXT
{
- CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(),
- uint32_t subpass_ = 0,
- Framebuffer framebuffer_ = Framebuffer(),
- Bool32 occlusionQueryEnable_ = 0,
- QueryControlFlags queryFlags_ = QueryControlFlags(),
- QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : renderPass( renderPass_ )
- , subpass( subpass_ )
- , framebuffer( framebuffer_ )
- , occlusionQueryEnable( occlusionQueryEnable_ )
- , queryFlags( queryFlags_ )
- , pipelineStatistics( pipelineStatistics_ )
+ DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+ uint64_t objectHandle_ = 0,
+ const char* pObjectName_ = nullptr )
+ : objectType( objectType_ )
+ , objectHandle( objectHandle_ )
+ , pObjectName( pObjectName_ )
{
}
- CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
+ DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
}
- CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
+ DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
return *this;
}
- CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
+ DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
- {
- renderPass = renderPass_;
- return *this;
- }
-
- CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
- {
- subpass = subpass_;
- return *this;
- }
-
- CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
+ DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ )
{
- framebuffer = framebuffer_;
+ objectType = objectType_;
return *this;
}
- CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
+ DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ )
{
- occlusionQueryEnable = occlusionQueryEnable_;
+ objectHandle = objectHandle_;
return *this;
}
- CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
+ DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
{
- queryFlags = queryFlags_;
+ pObjectName = pObjectName_;
return *this;
}
- CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+ operator VkDebugUtilsObjectNameInfoEXT const&() const
{
- pipelineStatistics = pipelineStatistics_;
- return *this;
+ return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(this);
}
- operator const VkCommandBufferInheritanceInfo&() const
+ operator VkDebugUtilsObjectNameInfoEXT &()
{
- return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
+ return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this);
}
- bool operator==( CommandBufferInheritanceInfo const& rhs ) const
+ bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( renderPass == rhs.renderPass )
- && ( subpass == rhs.subpass )
- && ( framebuffer == rhs.framebuffer )
- && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
- && ( queryFlags == rhs.queryFlags )
- && ( pipelineStatistics == rhs.pipelineStatistics );
+ && ( objectType == rhs.objectType )
+ && ( objectHandle == rhs.objectHandle )
+ && ( pObjectName == rhs.pObjectName );
}
- bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
+ bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eCommandBufferInheritanceInfo;
+ StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
public:
const void* pNext = nullptr;
- RenderPass renderPass;
- uint32_t subpass;
- Framebuffer framebuffer;
- Bool32 occlusionQueryEnable;
- QueryControlFlags queryFlags;
- QueryPipelineStatisticFlags pipelineStatistics;
+ ObjectType objectType;
+ uint64_t objectHandle;
+ const char* pObjectName;
};
- static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
- struct CommandBufferBeginInfo
+ struct DebugUtilsObjectTagInfoEXT
{
- CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(),
- const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
- : flags( flags_ )
- , pInheritanceInfo( pInheritanceInfo_ )
+ DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+ uint64_t objectHandle_ = 0,
+ uint64_t tagName_ = 0,
+ size_t tagSize_ = 0,
+ const void* pTag_ = nullptr )
+ : objectType( objectType_ )
+ , objectHandle( objectHandle_ )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
{
}
- CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+ DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
}
- CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+ DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
return *this;
}
- CommandBufferBeginInfo& setPNext( const void* pNext_ )
+ DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
+ DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ )
{
- flags = flags_;
+ objectType = objectType_;
return *this;
}
- CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
+ DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ )
{
- pInheritanceInfo = pInheritanceInfo_;
+ objectHandle = objectHandle_;
return *this;
}
- operator const VkCommandBufferBeginInfo&() const
+ DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ )
{
- return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
+ tagName = tagName_;
+ return *this;
}
- bool operator==( CommandBufferBeginInfo const& rhs ) const
+ DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( pInheritanceInfo == rhs.pInheritanceInfo );
+ tagSize = tagSize_;
+ return *this;
}
- bool operator!=( CommandBufferBeginInfo const& rhs ) const
+ DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ )
{
- return !operator==( rhs );
+ pTag = pTag_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eCommandBufferBeginInfo;
+ operator VkDebugUtilsObjectTagInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(this);
+ }
- public:
- const void* pNext = nullptr;
- CommandBufferUsageFlags flags;
- const CommandBufferInheritanceInfo* pInheritanceInfo;
- };
- static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
+ operator VkDebugUtilsObjectTagInfoEXT &()
+ {
+ return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this);
+ }
- struct QueryPoolCreateInfo
+ bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( objectType == rhs.objectType )
+ && ( objectHandle == rhs.objectHandle )
+ && ( tagName == rhs.tagName )
+ && ( tagSize == rhs.tagSize )
+ && ( pTag == rhs.pTag );
+ }
+
+ bool operator!=( DebugUtilsObjectTagInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ ObjectType objectType;
+ uint64_t objectHandle;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
+ };
+ static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
+
+ struct DebugUtilsMessengerCallbackDataEXT
{
- QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(),
- QueryType queryType_ = QueryType::eOcclusion,
- uint32_t queryCount_ = 0,
- QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
+ DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(),
+ const char* pMessageIdName_ = nullptr,
+ int32_t messageIdNumber_ = 0,
+ const char* pMessage_ = nullptr,
+ uint32_t queueLabelCount_ = 0,
+ DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
+ uint32_t cmdBufLabelCount_ = 0,
+ DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
+ uint32_t objectCount_ = 0,
+ DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
: flags( flags_ )
- , queryType( queryType_ )
- , queryCount( queryCount_ )
- , pipelineStatistics( pipelineStatistics_ )
+ , pMessageIdName( pMessageIdName_ )
+ , messageIdNumber( messageIdNumber_ )
+ , pMessage( pMessage_ )
+ , queueLabelCount( queueLabelCount_ )
+ , pQueueLabels( pQueueLabels_ )
+ , cmdBufLabelCount( cmdBufLabelCount_ )
+ , pCmdBufLabels( pCmdBufLabels_ )
+ , objectCount( objectCount_ )
+ , pObjects( pObjects_ )
{
}
- QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
+ DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
}
- QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
+ DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
return *this;
}
- QueryPoolCreateInfo& setPNext( const void* pNext_ )
+ DebugUtilsMessengerCallbackDataEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
+ DebugUtilsMessengerCallbackDataEXT& setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
+ DebugUtilsMessengerCallbackDataEXT& setPMessageIdName( const char* pMessageIdName_ )
{
- queryType = queryType_;
+ pMessageIdName = pMessageIdName_;
return *this;
}
- QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
+ DebugUtilsMessengerCallbackDataEXT& setMessageIdNumber( int32_t messageIdNumber_ )
{
- queryCount = queryCount_;
+ messageIdNumber = messageIdNumber_;
return *this;
}
- QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+ DebugUtilsMessengerCallbackDataEXT& setPMessage( const char* pMessage_ )
{
- pipelineStatistics = pipelineStatistics_;
+ pMessage = pMessage_;
return *this;
}
- operator const VkQueryPoolCreateInfo&() const
+ DebugUtilsMessengerCallbackDataEXT& setQueueLabelCount( uint32_t queueLabelCount_ )
{
- return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
+ queueLabelCount = queueLabelCount_;
+ return *this;
}
- bool operator==( QueryPoolCreateInfo const& rhs ) const
+ DebugUtilsMessengerCallbackDataEXT& setPQueueLabels( DebugUtilsLabelEXT* pQueueLabels_ )
+ {
+ pQueueLabels = pQueueLabels_;
+ return *this;
+ }
+
+ DebugUtilsMessengerCallbackDataEXT& setCmdBufLabelCount( uint32_t cmdBufLabelCount_ )
+ {
+ cmdBufLabelCount = cmdBufLabelCount_;
+ return *this;
+ }
+
+ DebugUtilsMessengerCallbackDataEXT& setPCmdBufLabels( DebugUtilsLabelEXT* pCmdBufLabels_ )
+ {
+ pCmdBufLabels = pCmdBufLabels_;
+ return *this;
+ }
+
+ DebugUtilsMessengerCallbackDataEXT& setObjectCount( uint32_t objectCount_ )
+ {
+ objectCount = objectCount_;
+ return *this;
+ }
+
+ DebugUtilsMessengerCallbackDataEXT& setPObjects( DebugUtilsObjectNameInfoEXT* pObjects_ )
+ {
+ pObjects = pObjects_;
+ return *this;
+ }
+
+ operator VkDebugUtilsMessengerCallbackDataEXT const&() const
+ {
+ return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(this);
+ }
+
+ operator VkDebugUtilsMessengerCallbackDataEXT &()
+ {
+ return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this);
+ }
+
+ bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( queryType == rhs.queryType )
- && ( queryCount == rhs.queryCount )
- && ( pipelineStatistics == rhs.pipelineStatistics );
+ && ( pMessageIdName == rhs.pMessageIdName )
+ && ( messageIdNumber == rhs.messageIdNumber )
+ && ( pMessage == rhs.pMessage )
+ && ( queueLabelCount == rhs.queueLabelCount )
+ && ( pQueueLabels == rhs.pQueueLabels )
+ && ( cmdBufLabelCount == rhs.cmdBufLabelCount )
+ && ( pCmdBufLabels == rhs.pCmdBufLabels )
+ && ( objectCount == rhs.objectCount )
+ && ( pObjects == rhs.pObjects );
}
- bool operator!=( QueryPoolCreateInfo const& rhs ) const
+ bool operator!=( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eQueryPoolCreateInfo;
+ StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
public:
const void* pNext = nullptr;
- QueryPoolCreateFlags flags;
- QueryType queryType;
- uint32_t queryCount;
- QueryPipelineStatisticFlags pipelineStatistics;
+ DebugUtilsMessengerCallbackDataFlagsEXT flags;
+ const char* pMessageIdName;
+ int32_t messageIdNumber;
+ const char* pMessage;
+ uint32_t queueLabelCount;
+ DebugUtilsLabelEXT* pQueueLabels;
+ uint32_t cmdBufLabelCount;
+ DebugUtilsLabelEXT* pCmdBufLabels;
+ uint32_t objectCount;
+ DebugUtilsObjectNameInfoEXT* pObjects;
};
- static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
- enum class ImageAspectFlagBits
+ enum class QueueFlagBits
{
- eColor = VK_IMAGE_ASPECT_COLOR_BIT,
- eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
- eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
- eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
- ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
- ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
- ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
- ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
- ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
- ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT
+ eGraphics = VK_QUEUE_GRAPHICS_BIT,
+ eCompute = VK_QUEUE_COMPUTE_BIT,
+ eTransfer = VK_QUEUE_TRANSFER_BIT,
+ eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
+ eProtected = VK_QUEUE_PROTECTED_BIT
};
- using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
+ using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
- VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
{
- return ImageAspectFlags( bit0 ) | bit1;
+ return QueueFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
+ VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
{
- return ~( ImageAspectFlags( bits ) );
+ return ~( QueueFlags( bits ) );
}
- template <> struct FlagTraits<ImageAspectFlagBits>
+ template <> struct FlagTraits<QueueFlagBits>
{
enum
{
- allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0) | VkFlags(ImageAspectFlagBits::ePlane1) | VkFlags(ImageAspectFlagBits::ePlane2)
+ allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) | VkFlags(QueueFlagBits::eProtected)
};
};
- struct ImageSubresource
+ struct QueueFamilyProperties
{
- ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t mipLevel_ = 0,
- uint32_t arrayLayer_ = 0 )
- : aspectMask( aspectMask_ )
- , mipLevel( mipLevel_ )
- , arrayLayer( arrayLayer_ )
- {
- }
-
- ImageSubresource( VkImageSubresource const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageSubresource ) );
- }
-
- ImageSubresource& operator=( VkImageSubresource const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageSubresource ) );
- return *this;
- }
- ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
- {
- aspectMask = aspectMask_;
- return *this;
- }
-
- ImageSubresource& setMipLevel( uint32_t mipLevel_ )
- {
- mipLevel = mipLevel_;
- return *this;
- }
-
- ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
+ operator VkQueueFamilyProperties const&() const
{
- arrayLayer = arrayLayer_;
- return *this;
+ return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
}
- operator const VkImageSubresource&() const
+ operator VkQueueFamilyProperties &()
{
- return *reinterpret_cast<const VkImageSubresource*>(this);
+ return *reinterpret_cast<VkQueueFamilyProperties*>(this);
}
- bool operator==( ImageSubresource const& rhs ) const
+ bool operator==( QueueFamilyProperties const& rhs ) const
{
- return ( aspectMask == rhs.aspectMask )
- && ( mipLevel == rhs.mipLevel )
- && ( arrayLayer == rhs.arrayLayer );
+ return ( queueFlags == rhs.queueFlags )
+ && ( queueCount == rhs.queueCount )
+ && ( timestampValidBits == rhs.timestampValidBits )
+ && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
}
- bool operator!=( ImageSubresource const& rhs ) const
+ bool operator!=( QueueFamilyProperties const& rhs ) const
{
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
- uint32_t mipLevel;
- uint32_t arrayLayer;
+ QueueFlags queueFlags;
+ uint32_t queueCount;
+ uint32_t timestampValidBits;
+ Extent3D minImageTransferGranularity;
};
- static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
+ static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
- struct ImageSubresourceLayers
+ struct QueueFamilyProperties2
{
- ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t mipLevel_ = 0,
- uint32_t baseArrayLayer_ = 0,
- uint32_t layerCount_ = 0 )
- : aspectMask( aspectMask_ )
- , mipLevel( mipLevel_ )
- , baseArrayLayer( baseArrayLayer_ )
- , layerCount( layerCount_ )
+ operator VkQueueFamilyProperties2 const&() const
{
+ return *reinterpret_cast<const VkQueueFamilyProperties2*>(this);
}
- ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
+ operator VkQueueFamilyProperties2 &()
{
- memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
+ return *reinterpret_cast<VkQueueFamilyProperties2*>(this);
}
- ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
- return *this;
- }
- ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
+ bool operator==( QueueFamilyProperties2 const& rhs ) const
{
- aspectMask = aspectMask_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( queueFamilyProperties == rhs.queueFamilyProperties );
}
- ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
+ bool operator!=( QueueFamilyProperties2 const& rhs ) const
{
- mipLevel = mipLevel_;
- return *this;
+ return !operator==( rhs );
}
- ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
- {
- baseArrayLayer = baseArrayLayer_;
- return *this;
- }
+ private:
+ StructureType sType = StructureType::eQueueFamilyProperties2;
- ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
- {
- layerCount = layerCount_;
- return *this;
- }
+ public:
+ void* pNext = nullptr;
+ QueueFamilyProperties queueFamilyProperties;
+ };
+ static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
- operator const VkImageSubresourceLayers&() const
- {
- return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
- }
+ using QueueFamilyProperties2KHR = QueueFamilyProperties2;
- bool operator==( ImageSubresourceLayers const& rhs ) const
- {
- return ( aspectMask == rhs.aspectMask )
- && ( mipLevel == rhs.mipLevel )
- && ( baseArrayLayer == rhs.baseArrayLayer )
- && ( layerCount == rhs.layerCount );
- }
+ enum class DeviceQueueCreateFlagBits
+ {
+ eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
+ };
- bool operator!=( ImageSubresourceLayers const& rhs ) const
- {
- return !operator==( rhs );
- }
+ using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
- ImageAspectFlags aspectMask;
- uint32_t mipLevel;
- uint32_t baseArrayLayer;
- uint32_t layerCount;
+ VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+ {
+ return DeviceQueueCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits )
+ {
+ return ~( DeviceQueueCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<DeviceQueueCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected)
+ };
};
- static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
- struct ImageSubresourceRange
+ struct DeviceQueueCreateInfo
{
- ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t baseMipLevel_ = 0,
- uint32_t levelCount_ = 0,
- uint32_t baseArrayLayer_ = 0,
- uint32_t layerCount_ = 0 )
- : aspectMask( aspectMask_ )
- , baseMipLevel( baseMipLevel_ )
- , levelCount( levelCount_ )
- , baseArrayLayer( baseArrayLayer_ )
- , layerCount( layerCount_ )
+ DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0,
+ uint32_t queueCount_ = 0,
+ const float* pQueuePriorities_ = nullptr )
+ : flags( flags_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ , queueCount( queueCount_ )
+ , pQueuePriorities( pQueuePriorities_ )
{
}
- ImageSubresourceRange( VkImageSubresourceRange const & rhs )
+ DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+ memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
}
- ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
+ DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+ memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
return *this;
}
- ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
+ DeviceQueueCreateInfo& setPNext( const void* pNext_ )
{
- aspectMask = aspectMask_;
+ pNext = pNext_;
return *this;
}
- ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
+ DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ )
{
- baseMipLevel = baseMipLevel_;
+ flags = flags_;
return *this;
}
- ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
+ DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
{
- levelCount = levelCount_;
+ queueFamilyIndex = queueFamilyIndex_;
return *this;
}
- ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
+ DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ )
{
- baseArrayLayer = baseArrayLayer_;
+ queueCount = queueCount_;
return *this;
}
- ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
+ DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ )
{
- layerCount = layerCount_;
+ pQueuePriorities = pQueuePriorities_;
return *this;
}
- operator const VkImageSubresourceRange&() const
+ operator VkDeviceQueueCreateInfo const&() const
{
- return *reinterpret_cast<const VkImageSubresourceRange*>(this);
+ return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
}
- bool operator==( ImageSubresourceRange const& rhs ) const
+ operator VkDeviceQueueCreateInfo &()
{
- return ( aspectMask == rhs.aspectMask )
- && ( baseMipLevel == rhs.baseMipLevel )
- && ( levelCount == rhs.levelCount )
- && ( baseArrayLayer == rhs.baseArrayLayer )
- && ( layerCount == rhs.layerCount );
+ return *reinterpret_cast<VkDeviceQueueCreateInfo*>(this);
}
- bool operator!=( ImageSubresourceRange const& rhs ) const
+ bool operator==( DeviceQueueCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( queueFamilyIndex == rhs.queueFamilyIndex )
+ && ( queueCount == rhs.queueCount )
+ && ( pQueuePriorities == rhs.pQueuePriorities );
+ }
+
+ bool operator!=( DeviceQueueCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
- uint32_t baseMipLevel;
- uint32_t levelCount;
- uint32_t baseArrayLayer;
- uint32_t layerCount;
+ private:
+ StructureType sType = StructureType::eDeviceQueueCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ DeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queueCount;
+ const float* pQueuePriorities;
};
- static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
- struct ImageMemoryBarrier
+ struct DeviceCreateInfo
{
- ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- ImageLayout oldLayout_ = ImageLayout::eUndefined,
- ImageLayout newLayout_ = ImageLayout::eUndefined,
- uint32_t srcQueueFamilyIndex_ = 0,
- uint32_t dstQueueFamilyIndex_ = 0,
- Image image_ = Image(),
- ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
- : srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , oldLayout( oldLayout_ )
- , newLayout( newLayout_ )
- , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
- , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
- , image( image_ )
- , subresourceRange( subresourceRange_ )
+ DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(),
+ uint32_t queueCreateInfoCount_ = 0,
+ const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
+ uint32_t enabledLayerCount_ = 0,
+ const char* const* ppEnabledLayerNames_ = nullptr,
+ uint32_t enabledExtensionCount_ = 0,
+ const char* const* ppEnabledExtensionNames_ = nullptr,
+ const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
+ : flags( flags_ )
+ , queueCreateInfoCount( queueCreateInfoCount_ )
+ , pQueueCreateInfos( pQueueCreateInfos_ )
+ , enabledLayerCount( enabledLayerCount_ )
+ , ppEnabledLayerNames( ppEnabledLayerNames_ )
+ , enabledExtensionCount( enabledExtensionCount_ )
+ , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+ , pEnabledFeatures( pEnabledFeatures_ )
{
}
- ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+ DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+ memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
}
- ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+ DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+ memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
return *this;
}
- ImageMemoryBarrier& setPNext( const void* pNext_ )
+ DeviceCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ )
{
- srcAccessMask = srcAccessMask_;
+ flags = flags_;
return *this;
}
- ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ )
{
- dstAccessMask = dstAccessMask_;
+ queueCreateInfoCount = queueCreateInfoCount_;
return *this;
}
- ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
+ DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
{
- oldLayout = oldLayout_;
+ pQueueCreateInfos = pQueueCreateInfos_;
return *this;
}
- ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
+ DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
{
- newLayout = newLayout_;
+ enabledLayerCount = enabledLayerCount_;
return *this;
}
- ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+ DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
{
- srcQueueFamilyIndex = srcQueueFamilyIndex_;
+ ppEnabledLayerNames = ppEnabledLayerNames_;
return *this;
}
- ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+ DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
{
- dstQueueFamilyIndex = dstQueueFamilyIndex_;
+ enabledExtensionCount = enabledExtensionCount_;
return *this;
}
- ImageMemoryBarrier& setImage( Image image_ )
+ DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
{
- image = image_;
+ ppEnabledExtensionNames = ppEnabledExtensionNames_;
return *this;
}
- ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
{
- subresourceRange = subresourceRange_;
+ pEnabledFeatures = pEnabledFeatures_;
return *this;
}
- operator const VkImageMemoryBarrier&() const
+ operator VkDeviceCreateInfo const&() const
{
- return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
+ return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
}
- bool operator==( ImageMemoryBarrier const& rhs ) const
+ operator VkDeviceCreateInfo &()
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( oldLayout == rhs.oldLayout )
- && ( newLayout == rhs.newLayout )
- && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
- && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
- && ( image == rhs.image )
- && ( subresourceRange == rhs.subresourceRange );
+ return *reinterpret_cast<VkDeviceCreateInfo*>(this);
}
- bool operator!=( ImageMemoryBarrier const& rhs ) const
+ bool operator==( DeviceCreateInfo const& rhs ) const
{
- return !operator==( rhs );
- }
-
- private:
- StructureType sType = StructureType::eImageMemoryBarrier;
-
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( queueCreateInfoCount == rhs.queueCreateInfoCount )
+ && ( pQueueCreateInfos == rhs.pQueueCreateInfos )
+ && ( enabledLayerCount == rhs.enabledLayerCount )
+ && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
+ && ( enabledExtensionCount == rhs.enabledExtensionCount )
+ && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames )
+ && ( pEnabledFeatures == rhs.pEnabledFeatures );
+ }
+
+ bool operator!=( DeviceCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eDeviceCreateInfo;
+
public:
const void* pNext = nullptr;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- ImageLayout oldLayout;
- ImageLayout newLayout;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- Image image;
- ImageSubresourceRange subresourceRange;
+ DeviceCreateFlags flags;
+ uint32_t queueCreateInfoCount;
+ const DeviceQueueCreateInfo* pQueueCreateInfos;
+ uint32_t enabledLayerCount;
+ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionCount;
+ const char* const* ppEnabledExtensionNames;
+ const PhysicalDeviceFeatures* pEnabledFeatures;
};
- static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
- struct ImageViewCreateInfo
+ struct DeviceQueueInfo2
{
- ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(),
- Image image_ = Image(),
- ImageViewType viewType_ = ImageViewType::e1D,
- Format format_ = Format::eUndefined,
- ComponentMapping components_ = ComponentMapping(),
- ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
+ DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0,
+ uint32_t queueIndex_ = 0 )
: flags( flags_ )
- , image( image_ )
- , viewType( viewType_ )
- , format( format_ )
- , components( components_ )
- , subresourceRange( subresourceRange_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ , queueIndex( queueIndex_ )
{
}
- ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
+ DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
}
- ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+ DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
return *this;
}
- ImageViewCreateInfo& setPNext( const void* pNext_ )
+ DeviceQueueInfo2& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
+ DeviceQueueInfo2& setFlags( DeviceQueueCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- ImageViewCreateInfo& setImage( Image image_ )
- {
- image = image_;
- return *this;
- }
-
- ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
- {
- viewType = viewType_;
- return *this;
- }
-
- ImageViewCreateInfo& setFormat( Format format_ )
+ DeviceQueueInfo2& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
{
- format = format_;
+ queueFamilyIndex = queueFamilyIndex_;
return *this;
}
- ImageViewCreateInfo& setComponents( ComponentMapping components_ )
+ DeviceQueueInfo2& setQueueIndex( uint32_t queueIndex_ )
{
- components = components_;
+ queueIndex = queueIndex_;
return *this;
}
- ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ operator VkDeviceQueueInfo2 const&() const
{
- subresourceRange = subresourceRange_;
- return *this;
+ return *reinterpret_cast<const VkDeviceQueueInfo2*>(this);
}
- operator const VkImageViewCreateInfo&() const
+ operator VkDeviceQueueInfo2 &()
{
- return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
+ return *reinterpret_cast<VkDeviceQueueInfo2*>(this);
}
- bool operator==( ImageViewCreateInfo const& rhs ) const
+ bool operator==( DeviceQueueInfo2 const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( image == rhs.image )
- && ( viewType == rhs.viewType )
- && ( format == rhs.format )
- && ( components == rhs.components )
- && ( subresourceRange == rhs.subresourceRange );
+ && ( queueFamilyIndex == rhs.queueFamilyIndex )
+ && ( queueIndex == rhs.queueIndex );
}
- bool operator!=( ImageViewCreateInfo const& rhs ) const
+ bool operator!=( DeviceQueueInfo2 const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImageViewCreateInfo;
+ StructureType sType = StructureType::eDeviceQueueInfo2;
public:
const void* pNext = nullptr;
- ImageViewCreateFlags flags;
- Image image;
- ImageViewType viewType;
- Format format;
- ComponentMapping components;
- ImageSubresourceRange subresourceRange;
+ DeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queueIndex;
};
- static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
- struct ImageCopy
+ enum class MemoryPropertyFlagBits
{
- ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
- Offset3D srcOffset_ = Offset3D(),
- ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
- Offset3D dstOffset_ = Offset3D(),
- Extent3D extent_ = Extent3D() )
- : srcSubresource( srcSubresource_ )
- , srcOffset( srcOffset_ )
- , dstSubresource( dstSubresource_ )
- , dstOffset( dstOffset_ )
- , extent( extent_ )
- {
- }
+ eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+ eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+ eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+ eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
+ eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
+ eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT
+ };
- ImageCopy( VkImageCopy const & rhs )
+ using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
+
+ VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+ {
+ return MemoryPropertyFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
+ {
+ return ~( MemoryPropertyFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<MemoryPropertyFlagBits>
+ {
+ enum
{
- memcpy( this, &rhs, sizeof( ImageCopy ) );
- }
+ allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected)
+ };
+ };
- ImageCopy& operator=( VkImageCopy const & rhs )
+ struct MemoryType
+ {
+ operator VkMemoryType const&() const
{
- memcpy( this, &rhs, sizeof( ImageCopy ) );
- return *this;
+ return *reinterpret_cast<const VkMemoryType*>(this);
}
- ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+
+ operator VkMemoryType &()
{
- srcSubresource = srcSubresource_;
- return *this;
+ return *reinterpret_cast<VkMemoryType*>(this);
}
- ImageCopy& setSrcOffset( Offset3D srcOffset_ )
+ bool operator==( MemoryType const& rhs ) const
{
- srcOffset = srcOffset_;
- return *this;
+ return ( propertyFlags == rhs.propertyFlags )
+ && ( heapIndex == rhs.heapIndex );
}
- ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ bool operator!=( MemoryType const& rhs ) const
{
- dstSubresource = dstSubresource_;
- return *this;
+ return !operator==( rhs );
}
- ImageCopy& setDstOffset( Offset3D dstOffset_ )
+ MemoryPropertyFlags propertyFlags;
+ uint32_t heapIndex;
+ };
+ static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
+
+ enum class MemoryHeapFlagBits
+ {
+ eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
+ eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
+ eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
+ };
+
+ using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
+
+ VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
+ {
+ return ~( MemoryHeapFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<MemoryHeapFlagBits>
+ {
+ enum
{
- dstOffset = dstOffset_;
- return *this;
- }
+ allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstance)
+ };
+ };
- ImageCopy& setExtent( Extent3D extent_ )
+ struct MemoryHeap
+ {
+ operator VkMemoryHeap const&() const
{
- extent = extent_;
- return *this;
+ return *reinterpret_cast<const VkMemoryHeap*>(this);
}
- operator const VkImageCopy&() const
+ operator VkMemoryHeap &()
{
- return *reinterpret_cast<const VkImageCopy*>(this);
+ return *reinterpret_cast<VkMemoryHeap*>(this);
}
- bool operator==( ImageCopy const& rhs ) const
+ bool operator==( MemoryHeap const& rhs ) const
{
- return ( srcSubresource == rhs.srcSubresource )
- && ( srcOffset == rhs.srcOffset )
- && ( dstSubresource == rhs.dstSubresource )
- && ( dstOffset == rhs.dstOffset )
- && ( extent == rhs.extent );
+ return ( size == rhs.size )
+ && ( flags == rhs.flags );
}
- bool operator!=( ImageCopy const& rhs ) const
+ bool operator!=( MemoryHeap const& rhs ) const
{
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffset;
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffset;
- Extent3D extent;
+ DeviceSize size;
+ MemoryHeapFlags flags;
};
- static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
- struct ImageBlit
+ struct PhysicalDeviceMemoryProperties
{
- ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
- std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } },
- ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
- std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
- : srcSubresource( srcSubresource_ )
- , dstSubresource( dstSubresource_ )
+ operator VkPhysicalDeviceMemoryProperties const&() const
{
- memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
- memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
}
- ImageBlit( VkImageBlit const & rhs )
+ operator VkPhysicalDeviceMemoryProperties &()
{
- memcpy( this, &rhs, sizeof( ImageBlit ) );
+ return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this);
}
- ImageBlit& operator=( VkImageBlit const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageBlit ) );
- return *this;
- }
- ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
{
- srcSubresource = srcSubresource_;
- return *this;
+ return ( memoryTypeCount == rhs.memoryTypeCount )
+ && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
+ && ( memoryHeapCount == rhs.memoryHeapCount )
+ && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
}
- ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+ bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
{
- memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
- return *this;
+ return !operator==( rhs );
}
- ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
- {
- dstSubresource = dstSubresource_;
- return *this;
- }
+ uint32_t memoryTypeCount;
+ MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ uint32_t memoryHeapCount;
+ MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
+ };
+ static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
- ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+ struct PhysicalDeviceMemoryProperties2
+ {
+ operator VkPhysicalDeviceMemoryProperties2 const&() const
{
- memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(this);
}
- operator const VkImageBlit&() const
+ operator VkPhysicalDeviceMemoryProperties2 &()
{
- return *reinterpret_cast<const VkImageBlit*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this);
}
- bool operator==( ImageBlit const& rhs ) const
+ bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const
{
- return ( srcSubresource == rhs.srcSubresource )
- && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
- && ( dstSubresource == rhs.dstSubresource )
- && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memoryProperties == rhs.memoryProperties );
}
- bool operator!=( ImageBlit const& rhs ) const
+ bool operator!=( PhysicalDeviceMemoryProperties2 const& rhs ) const
{
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffsets[2];
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffsets[2];
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+
+ public:
+ void* pNext = nullptr;
+ PhysicalDeviceMemoryProperties memoryProperties;
};
- static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
- struct BufferImageCopy
+ using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
+
+ enum class AccessFlagBits
{
- BufferImageCopy( DeviceSize bufferOffset_ = 0,
- uint32_t bufferRowLength_ = 0,
- uint32_t bufferImageHeight_ = 0,
- ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
- Offset3D imageOffset_ = Offset3D(),
- Extent3D imageExtent_ = Extent3D() )
- : bufferOffset( bufferOffset_ )
- , bufferRowLength( bufferRowLength_ )
- , bufferImageHeight( bufferImageHeight_ )
- , imageSubresource( imageSubresource_ )
- , imageOffset( imageOffset_ )
- , imageExtent( imageExtent_ )
- {
- }
+ eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+ eIndexRead = VK_ACCESS_INDEX_READ_BIT,
+ eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+ eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
+ eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+ eShaderRead = VK_ACCESS_SHADER_READ_BIT,
+ eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
+ eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+ eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+ eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+ eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+ eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
+ eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
+ eHostRead = VK_ACCESS_HOST_READ_BIT,
+ eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
+ eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
+ eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
+ eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+ eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+ eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+ eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+ eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
+ eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
+ eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+ eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV,
+ eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
+ eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV
+ };
- BufferImageCopy( VkBufferImageCopy const & rhs )
+ using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
+
+ VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
+ {
+ return ~( AccessFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<AccessFlagBits>
+ {
+ enum
{
- memcpy( this, &rhs, sizeof( BufferImageCopy ) );
- }
+ allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV)
+ };
+ };
- BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
+ struct MemoryBarrier
+ {
+ MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
+ AccessFlags dstAccessMask_ = AccessFlags() )
+ : srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
{
- memcpy( this, &rhs, sizeof( BufferImageCopy ) );
- return *this;
}
- BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
+
+ MemoryBarrier( VkMemoryBarrier const & rhs )
{
- bufferOffset = bufferOffset_;
- return *this;
+ memcpy( this, &rhs, sizeof( MemoryBarrier ) );
}
- BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
+ MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
{
- bufferRowLength = bufferRowLength_;
+ memcpy( this, &rhs, sizeof( MemoryBarrier ) );
return *this;
}
-
- BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
+ MemoryBarrier& setPNext( const void* pNext_ )
{
- bufferImageHeight = bufferImageHeight_;
+ pNext = pNext_;
return *this;
}
- BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+ MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
{
- imageSubresource = imageSubresource_;
+ srcAccessMask = srcAccessMask_;
return *this;
}
- BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
+ MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
{
- imageOffset = imageOffset_;
+ dstAccessMask = dstAccessMask_;
return *this;
}
- BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
+ operator VkMemoryBarrier const&() const
{
- imageExtent = imageExtent_;
- return *this;
+ return *reinterpret_cast<const VkMemoryBarrier*>(this);
}
- operator const VkBufferImageCopy&() const
+ operator VkMemoryBarrier &()
{
- return *reinterpret_cast<const VkBufferImageCopy*>(this);
+ return *reinterpret_cast<VkMemoryBarrier*>(this);
}
- bool operator==( BufferImageCopy const& rhs ) const
+ bool operator==( MemoryBarrier const& rhs ) const
{
- return ( bufferOffset == rhs.bufferOffset )
- && ( bufferRowLength == rhs.bufferRowLength )
- && ( bufferImageHeight == rhs.bufferImageHeight )
- && ( imageSubresource == rhs.imageSubresource )
- && ( imageOffset == rhs.imageOffset )
- && ( imageExtent == rhs.imageExtent );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask );
}
- bool operator!=( BufferImageCopy const& rhs ) const
+ bool operator!=( MemoryBarrier const& rhs ) const
{
return !operator==( rhs );
}
- DeviceSize bufferOffset;
- uint32_t bufferRowLength;
- uint32_t bufferImageHeight;
- ImageSubresourceLayers imageSubresource;
- Offset3D imageOffset;
- Extent3D imageExtent;
+ private:
+ StructureType sType = StructureType::eMemoryBarrier;
+
+ public:
+ const void* pNext = nullptr;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
};
- static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
- struct ImageResolve
+ struct BufferMemoryBarrier
{
- ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
- Offset3D srcOffset_ = Offset3D(),
- ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
- Offset3D dstOffset_ = Offset3D(),
- Extent3D extent_ = Extent3D() )
- : srcSubresource( srcSubresource_ )
- , srcOffset( srcOffset_ )
- , dstSubresource( dstSubresource_ )
- , dstOffset( dstOffset_ )
- , extent( extent_ )
+ BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
+ AccessFlags dstAccessMask_ = AccessFlags(),
+ uint32_t srcQueueFamilyIndex_ = 0,
+ uint32_t dstQueueFamilyIndex_ = 0,
+ Buffer buffer_ = Buffer(),
+ DeviceSize offset_ = 0,
+ DeviceSize size_ = 0 )
+ : srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+ , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+ , buffer( buffer_ )
+ , offset( offset_ )
+ , size( size_ )
{
}
- ImageResolve( VkImageResolve const & rhs )
+ BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageResolve ) );
+ memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
}
- ImageResolve& operator=( VkImageResolve const & rhs )
+ BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageResolve ) );
+ memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
return *this;
}
- ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ BufferMemoryBarrier& setPNext( const void* pNext_ )
{
- srcSubresource = srcSubresource_;
+ pNext = pNext_;
return *this;
}
- ImageResolve& setSrcOffset( Offset3D srcOffset_ )
+ BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
{
- srcOffset = srcOffset_;
+ srcAccessMask = srcAccessMask_;
return *this;
}
- ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
{
- dstSubresource = dstSubresource_;
+ dstAccessMask = dstAccessMask_;
return *this;
}
- ImageResolve& setDstOffset( Offset3D dstOffset_ )
+ BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
{
- dstOffset = dstOffset_;
+ srcQueueFamilyIndex = srcQueueFamilyIndex_;
return *this;
}
- ImageResolve& setExtent( Extent3D extent_ )
+ BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
{
- extent = extent_;
+ dstQueueFamilyIndex = dstQueueFamilyIndex_;
return *this;
}
- operator const VkImageResolve&() const
+ BufferMemoryBarrier& setBuffer( Buffer buffer_ )
{
- return *reinterpret_cast<const VkImageResolve*>(this);
+ buffer = buffer_;
+ return *this;
}
- bool operator==( ImageResolve const& rhs ) const
+ BufferMemoryBarrier& setOffset( DeviceSize offset_ )
{
- return ( srcSubresource == rhs.srcSubresource )
- && ( srcOffset == rhs.srcOffset )
- && ( dstSubresource == rhs.dstSubresource )
- && ( dstOffset == rhs.dstOffset )
- && ( extent == rhs.extent );
+ offset = offset_;
+ return *this;
}
- bool operator!=( ImageResolve const& rhs ) const
+ BufferMemoryBarrier& setSize( DeviceSize size_ )
{
- return !operator==( rhs );
+ size = size_;
+ return *this;
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffset;
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffset;
- Extent3D extent;
- };
- static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
+ operator VkBufferMemoryBarrier const&() const
+ {
+ return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
+ }
- struct ClearAttachment
- {
- ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t colorAttachment_ = 0,
- ClearValue clearValue_ = ClearValue() )
- : aspectMask( aspectMask_ )
- , colorAttachment( colorAttachment_ )
- , clearValue( clearValue_ )
+ operator VkBufferMemoryBarrier &()
{
+ return *reinterpret_cast<VkBufferMemoryBarrier*>(this);
}
- ClearAttachment( VkClearAttachment const & rhs )
+ bool operator==( BufferMemoryBarrier const& rhs ) const
{
- memcpy( this, &rhs, sizeof( ClearAttachment ) );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
+ && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
+ && ( buffer == rhs.buffer )
+ && ( offset == rhs.offset )
+ && ( size == rhs.size );
}
- ClearAttachment& operator=( VkClearAttachment const & rhs )
+ bool operator!=( BufferMemoryBarrier const& rhs ) const
{
- memcpy( this, &rhs, sizeof( ClearAttachment ) );
- return *this;
+ return !operator==( rhs );
}
- ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
+
+ private:
+ StructureType sType = StructureType::eBufferMemoryBarrier;
+
+ public:
+ const void* pNext = nullptr;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ Buffer buffer;
+ DeviceSize offset;
+ DeviceSize size;
+ };
+ static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
+
+ enum class BufferUsageFlagBits
+ {
+ eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+ eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+ eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
+ eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+ eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+ eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+ eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+ eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+ eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
+ eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
+ eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
+ eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+ eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV
+ };
+
+ using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
+
+ VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
+ {
+ return ~( BufferUsageFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<BufferUsageFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV)
+ };
+ };
+
+ enum class BufferCreateFlagBits
+ {
+ eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+ eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
+ eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+ eProtected = VK_BUFFER_CREATE_PROTECTED_BIT
+ };
+
+ using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
+
+ VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
+ {
+ return ~( BufferCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<BufferCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected)
+ };
+ };
+
+ struct BufferCreateInfo
+ {
+ BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
+ DeviceSize size_ = 0,
+ BufferUsageFlags usage_ = BufferUsageFlags(),
+ SharingMode sharingMode_ = SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr )
+ : flags( flags_ )
+ , size( size_ )
+ , usage( usage_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
{
- aspectMask = aspectMask_;
- return *this;
}
- ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
+ BufferCreateInfo( VkBufferCreateInfo const & rhs )
{
- colorAttachment = colorAttachment_;
- return *this;
+ memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
}
- ClearAttachment& setClearValue( ClearValue clearValue_ )
+ BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
{
- clearValue = clearValue_;
+ memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
return *this;
}
-
- operator const VkClearAttachment&() const
+ BufferCreateInfo& setPNext( const void* pNext_ )
{
- return *reinterpret_cast<const VkClearAttachment*>(this);
+ pNext = pNext_;
+ return *this;
}
- ImageAspectFlags aspectMask;
- uint32_t colorAttachment;
- ClearValue clearValue;
- };
- static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
-
- struct InputAttachmentAspectReference
- {
- InputAttachmentAspectReference( uint32_t subpass_ = 0,
- uint32_t inputAttachmentIndex_ = 0,
- ImageAspectFlags aspectMask_ = ImageAspectFlags() )
- : subpass( subpass_ )
- , inputAttachmentIndex( inputAttachmentIndex_ )
- , aspectMask( aspectMask_ )
+ BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
{
+ flags = flags_;
+ return *this;
}
- InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs )
+ BufferCreateInfo& setSize( DeviceSize size_ )
{
- memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+ size = size_;
+ return *this;
}
- InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs )
+ BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
{
- memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+ usage = usage_;
return *this;
}
- InputAttachmentAspectReference& setSubpass( uint32_t subpass_ )
+
+ BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
{
- subpass = subpass_;
+ sharingMode = sharingMode_;
return *this;
}
- InputAttachmentAspectReference& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ )
+ BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
{
- inputAttachmentIndex = inputAttachmentIndex_;
+ queueFamilyIndexCount = queueFamilyIndexCount_;
return *this;
}
- InputAttachmentAspectReference& setAspectMask( ImageAspectFlags aspectMask_ )
+ BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
{
- aspectMask = aspectMask_;
+ pQueueFamilyIndices = pQueueFamilyIndices_;
return *this;
}
- operator const VkInputAttachmentAspectReference&() const
+ operator VkBufferCreateInfo const&() const
{
- return *reinterpret_cast<const VkInputAttachmentAspectReference*>(this);
+ return *reinterpret_cast<const VkBufferCreateInfo*>(this);
}
- bool operator==( InputAttachmentAspectReference const& rhs ) const
+ operator VkBufferCreateInfo &()
{
- return ( subpass == rhs.subpass )
- && ( inputAttachmentIndex == rhs.inputAttachmentIndex )
- && ( aspectMask == rhs.aspectMask );
+ return *reinterpret_cast<VkBufferCreateInfo*>(this);
}
- bool operator!=( InputAttachmentAspectReference const& rhs ) const
+ bool operator==( BufferCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( size == rhs.size )
+ && ( usage == rhs.usage )
+ && ( sharingMode == rhs.sharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+ }
+
+ bool operator!=( BufferCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t subpass;
- uint32_t inputAttachmentIndex;
- ImageAspectFlags aspectMask;
+ private:
+ StructureType sType = StructureType::eBufferCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ BufferCreateFlags flags;
+ DeviceSize size;
+ BufferUsageFlags usage;
+ SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
};
- static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
+ static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
- using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
+ enum class ShaderStageFlagBits
+ {
+ eVertex = VK_SHADER_STAGE_VERTEX_BIT,
+ eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
+ eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
+ eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
+ eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
+ eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
+ eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
+ eAll = VK_SHADER_STAGE_ALL,
+ eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV,
+ eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV,
+ eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV,
+ eMissNV = VK_SHADER_STAGE_MISS_BIT_NV,
+ eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV,
+ eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV,
+ eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
+ eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV
+ };
- struct RenderPassInputAttachmentAspectCreateInfo
+ using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
+
+ VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
{
- RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
- const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
- : aspectReferenceCount( aspectReferenceCount_ )
- , pAspectReferences( pAspectReferences_ )
+ return ShaderStageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
+ {
+ return ~( ShaderStageFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ShaderStageFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) | VkFlags(ShaderStageFlagBits::eRaygenNV) | VkFlags(ShaderStageFlagBits::eAnyHitNV) | VkFlags(ShaderStageFlagBits::eClosestHitNV) | VkFlags(ShaderStageFlagBits::eMissNV) | VkFlags(ShaderStageFlagBits::eIntersectionNV) | VkFlags(ShaderStageFlagBits::eCallableNV) | VkFlags(ShaderStageFlagBits::eTaskNV) | VkFlags(ShaderStageFlagBits::eMeshNV)
+ };
+ };
+
+ struct DescriptorSetLayoutBinding
+ {
+ DescriptorSetLayoutBinding( uint32_t binding_ = 0,
+ DescriptorType descriptorType_ = DescriptorType::eSampler,
+ uint32_t descriptorCount_ = 0,
+ ShaderStageFlags stageFlags_ = ShaderStageFlags(),
+ const Sampler* pImmutableSamplers_ = nullptr )
+ : binding( binding_ )
+ , descriptorType( descriptorType_ )
+ , descriptorCount( descriptorCount_ )
+ , stageFlags( stageFlags_ )
+ , pImmutableSamplers( pImmutableSamplers_ )
{
}
- RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+ DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
}
- RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+ DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
return *this;
}
- RenderPassInputAttachmentAspectCreateInfo& setPNext( const void* pNext_ )
+ DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
{
- pNext = pNext_;
+ binding = binding_;
return *this;
}
- RenderPassInputAttachmentAspectCreateInfo& setAspectReferenceCount( uint32_t aspectReferenceCount_ )
+ DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
{
- aspectReferenceCount = aspectReferenceCount_;
+ descriptorType = descriptorType_;
return *this;
}
- RenderPassInputAttachmentAspectCreateInfo& setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ )
+ DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
{
- pAspectReferences = pAspectReferences_;
+ descriptorCount = descriptorCount_;
return *this;
}
- operator const VkRenderPassInputAttachmentAspectCreateInfo&() const
+ DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
{
- return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(this);
+ stageFlags = stageFlags_;
+ return *this;
}
- bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
+ DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( aspectReferenceCount == rhs.aspectReferenceCount )
- && ( pAspectReferences == rhs.pAspectReferences );
+ pImmutableSamplers = pImmutableSamplers_;
+ return *this;
}
- bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
+ operator VkDescriptorSetLayoutBinding const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
}
- private:
- StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+ operator VkDescriptorSetLayoutBinding &()
+ {
+ return *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this);
+ }
- public:
- const void* pNext = nullptr;
- uint32_t aspectReferenceCount;
- const InputAttachmentAspectReference* pAspectReferences;
- };
- static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
+ bool operator==( DescriptorSetLayoutBinding const& rhs ) const
+ {
+ return ( binding == rhs.binding )
+ && ( descriptorType == rhs.descriptorType )
+ && ( descriptorCount == rhs.descriptorCount )
+ && ( stageFlags == rhs.stageFlags )
+ && ( pImmutableSamplers == rhs.pImmutableSamplers );
+ }
- using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
+ bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- struct BindImagePlaneMemoryInfo
+ uint32_t binding;
+ DescriptorType descriptorType;
+ uint32_t descriptorCount;
+ ShaderStageFlags stageFlags;
+ const Sampler* pImmutableSamplers;
+ };
+ static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
+
+ struct PipelineShaderStageCreateInfo
{
- BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
- : planeAspect( planeAspect_ )
+ PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(),
+ ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex,
+ ShaderModule module_ = ShaderModule(),
+ const char* pName_ = nullptr,
+ const SpecializationInfo* pSpecializationInfo_ = nullptr )
+ : flags( flags_ )
+ , stage( stage_ )
+ , module( module_ )
+ , pName( pName_ )
+ , pSpecializationInfo( pSpecializationInfo_ )
{
}
- BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
+ PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
}
- BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
+ PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
return *this;
}
- BindImagePlaneMemoryInfo& setPNext( const void* pNext_ )
+ PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- BindImagePlaneMemoryInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+ PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
{
- planeAspect = planeAspect_;
+ flags = flags_;
return *this;
}
- operator const VkBindImagePlaneMemoryInfo&() const
+ PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
{
- return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(this);
+ stage = stage_;
+ return *this;
}
- bool operator==( BindImagePlaneMemoryInfo const& rhs ) const
+ PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
+ {
+ module = module_;
+ return *this;
+ }
+
+ PipelineShaderStageCreateInfo& setPName( const char* pName_ )
+ {
+ pName = pName_;
+ return *this;
+ }
+
+ PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
+ {
+ pSpecializationInfo = pSpecializationInfo_;
+ return *this;
+ }
+
+ operator VkPipelineShaderStageCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
+ }
+
+ operator VkPipelineShaderStageCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this);
+ }
+
+ bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( planeAspect == rhs.planeAspect );
+ && ( flags == rhs.flags )
+ && ( stage == rhs.stage )
+ && ( module == rhs.module )
+ && ( pName == rhs.pName )
+ && ( pSpecializationInfo == rhs.pSpecializationInfo );
}
- bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const
+ bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
+ StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
public:
const void* pNext = nullptr;
- ImageAspectFlagBits planeAspect;
+ PipelineShaderStageCreateFlags flags;
+ ShaderStageFlagBits stage;
+ ShaderModule module;
+ const char* pName;
+ const SpecializationInfo* pSpecializationInfo;
};
- static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
-
- using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
+ static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
- struct ImagePlaneMemoryRequirementsInfo
+ struct PushConstantRange
{
- ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
- : planeAspect( planeAspect_ )
+ PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(),
+ uint32_t offset_ = 0,
+ uint32_t size_ = 0 )
+ : stageFlags( stageFlags_ )
+ , offset( offset_ )
+ , size( size_ )
{
}
- ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
+ PushConstantRange( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+ memcpy( this, &rhs, sizeof( PushConstantRange ) );
}
- ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
+ PushConstantRange& operator=( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+ memcpy( this, &rhs, sizeof( PushConstantRange ) );
return *this;
}
- ImagePlaneMemoryRequirementsInfo& setPNext( const void* pNext_ )
+ PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
{
- pNext = pNext_;
+ stageFlags = stageFlags_;
return *this;
}
- ImagePlaneMemoryRequirementsInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+ PushConstantRange& setOffset( uint32_t offset_ )
{
- planeAspect = planeAspect_;
+ offset = offset_;
return *this;
}
- operator const VkImagePlaneMemoryRequirementsInfo&() const
+ PushConstantRange& setSize( uint32_t size_ )
{
- return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(this);
+ size = size_;
+ return *this;
}
- bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const
+ operator VkPushConstantRange const&() const
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( planeAspect == rhs.planeAspect );
+ return *reinterpret_cast<const VkPushConstantRange*>(this);
}
- bool operator!=( ImagePlaneMemoryRequirementsInfo const& rhs ) const
+ operator VkPushConstantRange &()
{
- return !operator==( rhs );
+ return *reinterpret_cast<VkPushConstantRange*>(this);
}
- private:
- StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
+ bool operator==( PushConstantRange const& rhs ) const
+ {
+ return ( stageFlags == rhs.stageFlags )
+ && ( offset == rhs.offset )
+ && ( size == rhs.size );
+ }
- public:
- const void* pNext = nullptr;
- ImageAspectFlagBits planeAspect;
- };
- static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
+ bool operator!=( PushConstantRange const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
+ ShaderStageFlags stageFlags;
+ uint32_t offset;
+ uint32_t size;
+ };
+ static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
- struct AttachmentReference2KHR
+ struct PipelineLayoutCreateInfo
{
- AttachmentReference2KHR( uint32_t attachment_ = 0,
- ImageLayout layout_ = ImageLayout::eUndefined,
- ImageAspectFlags aspectMask_ = ImageAspectFlags() )
- : attachment( attachment_ )
- , layout( layout_ )
- , aspectMask( aspectMask_ )
+ PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(),
+ uint32_t setLayoutCount_ = 0,
+ const DescriptorSetLayout* pSetLayouts_ = nullptr,
+ uint32_t pushConstantRangeCount_ = 0,
+ const PushConstantRange* pPushConstantRanges_ = nullptr )
+ : flags( flags_ )
+ , setLayoutCount( setLayoutCount_ )
+ , pSetLayouts( pSetLayouts_ )
+ , pushConstantRangeCount( pushConstantRangeCount_ )
+ , pPushConstantRanges( pPushConstantRanges_ )
{
}
- AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
+ PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+ memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
}
- AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
+ PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+ memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
return *this;
}
- AttachmentReference2KHR& setPNext( const void* pNext_ )
+ PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- AttachmentReference2KHR& setAttachment( uint32_t attachment_ )
+ PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
{
- attachment = attachment_;
+ flags = flags_;
return *this;
}
- AttachmentReference2KHR& setLayout( ImageLayout layout_ )
+ PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
{
- layout = layout_;
+ setLayoutCount = setLayoutCount_;
return *this;
}
- AttachmentReference2KHR& setAspectMask( ImageAspectFlags aspectMask_ )
+ PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
{
- aspectMask = aspectMask_;
+ pSetLayouts = pSetLayouts_;
return *this;
}
- operator const VkAttachmentReference2KHR&() const
+ PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
{
- return *reinterpret_cast<const VkAttachmentReference2KHR*>(this);
+ pushConstantRangeCount = pushConstantRangeCount_;
+ return *this;
}
- bool operator==( AttachmentReference2KHR const& rhs ) const
+ PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+ {
+ pPushConstantRanges = pPushConstantRanges_;
+ return *this;
+ }
+
+ operator VkPipelineLayoutCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
+ }
+
+ operator VkPipelineLayoutCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this);
+ }
+
+ bool operator==( PipelineLayoutCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( attachment == rhs.attachment )
- && ( layout == rhs.layout )
- && ( aspectMask == rhs.aspectMask );
+ && ( flags == rhs.flags )
+ && ( setLayoutCount == rhs.setLayoutCount )
+ && ( pSetLayouts == rhs.pSetLayouts )
+ && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
+ && ( pPushConstantRanges == rhs.pPushConstantRanges );
}
- bool operator!=( AttachmentReference2KHR const& rhs ) const
+ bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eAttachmentReference2KHR;
+ StructureType sType = StructureType::ePipelineLayoutCreateInfo;
public:
const void* pNext = nullptr;
- uint32_t attachment;
- ImageLayout layout;
- ImageAspectFlags aspectMask;
+ PipelineLayoutCreateFlags flags;
+ uint32_t setLayoutCount;
+ const DescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const PushConstantRange* pPushConstantRanges;
};
- static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
- enum class SparseImageFormatFlagBits
+ struct ShaderStatisticsInfoAMD
{
- eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
- eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
- eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
+ operator VkShaderStatisticsInfoAMD const&() const
+ {
+ return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
+ }
+
+ operator VkShaderStatisticsInfoAMD &()
+ {
+ return *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this);
+ }
+
+ bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
+ {
+ return ( shaderStageMask == rhs.shaderStageMask )
+ && ( resourceUsage == rhs.resourceUsage )
+ && ( numPhysicalVgprs == rhs.numPhysicalVgprs )
+ && ( numPhysicalSgprs == rhs.numPhysicalSgprs )
+ && ( numAvailableVgprs == rhs.numAvailableVgprs )
+ && ( numAvailableSgprs == rhs.numAvailableSgprs )
+ && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
+ }
+
+ bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ShaderStageFlags shaderStageMask;
+ ShaderResourceUsageAMD resourceUsage;
+ uint32_t numPhysicalVgprs;
+ uint32_t numPhysicalSgprs;
+ uint32_t numAvailableVgprs;
+ uint32_t numAvailableSgprs;
+ uint32_t computeWorkGroupSize[3];
};
+ static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
- using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
+ enum class ImageUsageFlagBits
+ {
+ eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+ eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+ eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
+ eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
+ eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+ eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+ eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+ eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+ eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV
+ };
- VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
+
+ VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
{
- return SparseImageFormatFlags( bit0 ) | bit1;
+ return ImageUsageFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
+ VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
{
- return ~( SparseImageFormatFlags( bits ) );
+ return ~( ImageUsageFlags( bits ) );
}
- template <> struct FlagTraits<SparseImageFormatFlagBits>
+ template <> struct FlagTraits<ImageUsageFlagBits>
{
enum
{
- allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
+ allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV)
};
};
- struct SparseImageFormatProperties
+ struct SharedPresentSurfaceCapabilitiesKHR
{
- operator const VkSparseImageFormatProperties&() const
+ operator VkSharedPresentSurfaceCapabilitiesKHR const&() const
{
- return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
+ return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
}
- bool operator==( SparseImageFormatProperties const& rhs ) const
+ operator VkSharedPresentSurfaceCapabilitiesKHR &()
{
- return ( aspectMask == rhs.aspectMask )
- && ( imageGranularity == rhs.imageGranularity )
- && ( flags == rhs.flags );
+ return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this);
}
- bool operator!=( SparseImageFormatProperties const& rhs ) const
+ bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
+ }
+
+ bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
{
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
- Extent3D imageGranularity;
- SparseImageFormatFlags flags;
+ private:
+ StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+
+ public:
+ void* pNext = nullptr;
+ ImageUsageFlags sharedPresentSupportedUsageFlags;
};
- static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
- struct SparseImageMemoryRequirements
+ struct ImageViewUsageCreateInfo
{
- operator const VkSparseImageMemoryRequirements&() const
+ ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() )
+ : usage( usage_ )
{
- return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
}
- bool operator==( SparseImageMemoryRequirements const& rhs ) const
+ ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
{
- return ( formatProperties == rhs.formatProperties )
- && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
- && ( imageMipTailSize == rhs.imageMipTailSize )
- && ( imageMipTailOffset == rhs.imageMipTailOffset )
- && ( imageMipTailStride == rhs.imageMipTailStride );
+ memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
}
- bool operator!=( SparseImageMemoryRequirements const& rhs ) const
+ ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
+ return *this;
}
-
- SparseImageFormatProperties formatProperties;
- uint32_t imageMipTailFirstLod;
- DeviceSize imageMipTailSize;
- DeviceSize imageMipTailOffset;
- DeviceSize imageMipTailStride;
- };
- static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
-
- struct SparseImageFormatProperties2
- {
- operator const VkSparseImageFormatProperties2&() const
+ ImageViewUsageCreateInfo& setPNext( const void* pNext_ )
{
- return *reinterpret_cast<const VkSparseImageFormatProperties2*>(this);
+ pNext = pNext_;
+ return *this;
}
- bool operator==( SparseImageFormatProperties2 const& rhs ) const
+ ImageViewUsageCreateInfo& setUsage( ImageUsageFlags usage_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( properties == rhs.properties );
+ usage = usage_;
+ return *this;
}
- bool operator!=( SparseImageFormatProperties2 const& rhs ) const
+ operator VkImageViewUsageCreateInfo const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkImageViewUsageCreateInfo*>(this);
}
- private:
- StructureType sType = StructureType::eSparseImageFormatProperties2;
-
- public:
- void* pNext = nullptr;
- SparseImageFormatProperties properties;
- };
- static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
-
- using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
-
- struct SparseImageMemoryRequirements2
- {
- operator const VkSparseImageMemoryRequirements2&() const
+ operator VkImageViewUsageCreateInfo &()
{
- return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>(this);
+ return *reinterpret_cast<VkImageViewUsageCreateInfo*>(this);
}
- bool operator==( SparseImageMemoryRequirements2 const& rhs ) const
+ bool operator==( ImageViewUsageCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memoryRequirements == rhs.memoryRequirements );
+ && ( usage == rhs.usage );
}
- bool operator!=( SparseImageMemoryRequirements2 const& rhs ) const
+ bool operator!=( ImageViewUsageCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSparseImageMemoryRequirements2;
+ StructureType sType = StructureType::eImageViewUsageCreateInfo;
public:
- void* pNext = nullptr;
- SparseImageMemoryRequirements memoryRequirements;
+ const void* pNext = nullptr;
+ ImageUsageFlags usage;
};
- static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
- using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
+ using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
- enum class SparseMemoryBindFlagBits
+ enum class ImageCreateFlagBits
{
- eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
+ eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
+ eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
+ eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
+ eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
+ eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
+ eAlias = VK_IMAGE_CREATE_ALIAS_BIT,
+ eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT,
+ eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+ eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+ e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+ e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+ eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+ eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+ eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+ eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+ eProtected = VK_IMAGE_CREATE_PROTECTED_BIT,
+ eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
+ eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT,
+ eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
+ eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT
};
- using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
+ using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
- VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
{
- return SparseMemoryBindFlags( bit0 ) | bit1;
+ return ImageCreateFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
+ VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
{
- return ~( SparseMemoryBindFlags( bits ) );
+ return ~( ImageCreateFlags( bits ) );
}
- template <> struct FlagTraits<SparseMemoryBindFlagBits>
+ template <> struct FlagTraits<ImageCreateFlagBits>
{
enum
{
- allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
+ allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT)
};
};
- struct SparseMemoryBind
+ struct PhysicalDeviceImageFormatInfo2
{
- SparseMemoryBind( DeviceSize resourceOffset_ = 0,
- DeviceSize size_ = 0,
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0,
- SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
- : resourceOffset( resourceOffset_ )
- , size( size_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
+ PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined,
+ ImageType type_ = ImageType::e1D,
+ ImageTiling tiling_ = ImageTiling::eOptimal,
+ ImageUsageFlags usage_ = ImageUsageFlags(),
+ ImageCreateFlags flags_ = ImageCreateFlags() )
+ : format( format_ )
+ , type( type_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
, flags( flags_ )
{
}
- SparseMemoryBind( VkSparseMemoryBind const & rhs )
+ PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
}
- SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
+ PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
return *this;
}
- SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
+ PhysicalDeviceImageFormatInfo2& setPNext( const void* pNext_ )
{
- resourceOffset = resourceOffset_;
+ pNext = pNext_;
return *this;
}
- SparseMemoryBind& setSize( DeviceSize size_ )
+ PhysicalDeviceImageFormatInfo2& setFormat( Format format_ )
{
- size = size_;
+ format = format_;
return *this;
}
- SparseMemoryBind& setMemory( DeviceMemory memory_ )
+ PhysicalDeviceImageFormatInfo2& setType( ImageType type_ )
{
- memory = memory_;
+ type = type_;
return *this;
}
- SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ PhysicalDeviceImageFormatInfo2& setTiling( ImageTiling tiling_ )
{
- memoryOffset = memoryOffset_;
+ tiling = tiling_;
return *this;
}
- SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ PhysicalDeviceImageFormatInfo2& setUsage( ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ PhysicalDeviceImageFormatInfo2& setFlags( ImageCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- operator const VkSparseMemoryBind&() const
+ operator VkPhysicalDeviceImageFormatInfo2 const&() const
{
- return *reinterpret_cast<const VkSparseMemoryBind*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(this);
}
- bool operator==( SparseMemoryBind const& rhs ) const
+ operator VkPhysicalDeviceImageFormatInfo2 &()
{
- return ( resourceOffset == rhs.resourceOffset )
- && ( size == rhs.size )
- && ( memory == rhs.memory )
- && ( memoryOffset == rhs.memoryOffset )
+ return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this);
+ }
+
+ bool operator==( PhysicalDeviceImageFormatInfo2 const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( format == rhs.format )
+ && ( type == rhs.type )
+ && ( tiling == rhs.tiling )
+ && ( usage == rhs.usage )
&& ( flags == rhs.flags );
}
- bool operator!=( SparseMemoryBind const& rhs ) const
+ bool operator!=( PhysicalDeviceImageFormatInfo2 const& rhs ) const
{
return !operator==( rhs );
}
- DeviceSize resourceOffset;
- DeviceSize size;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- SparseMemoryBindFlags flags;
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
+
+ public:
+ const void* pNext = nullptr;
+ Format format;
+ ImageType type;
+ ImageTiling tiling;
+ ImageUsageFlags usage;
+ ImageCreateFlags flags;
};
- static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" );
- struct SparseImageMemoryBind
+ using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
+
+ enum class PipelineCreateFlagBits
{
- SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(),
- Offset3D offset_ = Offset3D(),
- Extent3D extent_ = Extent3D(),
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0,
- SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
- : subresource( subresource_ )
- , offset( offset_ )
- , extent( extent_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
- , flags( flags_ )
+ eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
+ eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
+ eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
+ eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+ eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+ eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
+ eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
+ eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV
+ };
+
+ using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
+
+ VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
+ {
+ return ~( PipelineCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<PipelineCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV)
+ };
+ };
+
+ struct ComputePipelineCreateInfo
+ {
+ ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+ PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(),
+ PipelineLayout layout_ = PipelineLayout(),
+ Pipeline basePipelineHandle_ = Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : flags( flags_ )
+ , stage( stage_ )
+ , layout( layout_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
{
}
- SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
+ ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+ memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
}
- SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
+ ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+ memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
return *this;
}
- SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
+ ComputePipelineCreateInfo& setPNext( const void* pNext_ )
{
- subresource = subresource_;
+ pNext = pNext_;
return *this;
}
- SparseImageMemoryBind& setOffset( Offset3D offset_ )
+ ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
{
- offset = offset_;
+ flags = flags_;
return *this;
}
- SparseImageMemoryBind& setExtent( Extent3D extent_ )
+ ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
{
- extent = extent_;
+ stage = stage_;
return *this;
}
- SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
+ ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
{
- memory = memory_;
+ layout = layout_;
return *this;
}
- SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
{
- memoryOffset = memoryOffset_;
+ basePipelineHandle = basePipelineHandle_;
return *this;
}
- SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
{
- flags = flags_;
+ basePipelineIndex = basePipelineIndex_;
return *this;
}
- operator const VkSparseImageMemoryBind&() const
+ operator VkComputePipelineCreateInfo const&() const
{
- return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
+ return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
}
- bool operator==( SparseImageMemoryBind const& rhs ) const
+ operator VkComputePipelineCreateInfo &()
{
- return ( subresource == rhs.subresource )
- && ( offset == rhs.offset )
- && ( extent == rhs.extent )
- && ( memory == rhs.memory )
- && ( memoryOffset == rhs.memoryOffset )
- && ( flags == rhs.flags );
+ return *reinterpret_cast<VkComputePipelineCreateInfo*>(this);
}
- bool operator!=( SparseImageMemoryBind const& rhs ) const
+ bool operator==( ComputePipelineCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( stage == rhs.stage )
+ && ( layout == rhs.layout )
+ && ( basePipelineHandle == rhs.basePipelineHandle )
+ && ( basePipelineIndex == rhs.basePipelineIndex );
+ }
+
+ bool operator!=( ComputePipelineCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- ImageSubresource subresource;
- Offset3D offset;
- Extent3D extent;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- SparseMemoryBindFlags flags;
+ private:
+ StructureType sType = StructureType::eComputePipelineCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ PipelineCreateFlags flags;
+ PipelineShaderStageCreateInfo stage;
+ PipelineLayout layout;
+ Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
};
- static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
- struct SparseBufferMemoryBindInfo
+ enum class ColorComponentFlagBits
{
- SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(),
- uint32_t bindCount_ = 0,
- const SparseMemoryBind* pBinds_ = nullptr )
- : buffer( buffer_ )
- , bindCount( bindCount_ )
- , pBinds( pBinds_ )
+ eR = VK_COLOR_COMPONENT_R_BIT,
+ eG = VK_COLOR_COMPONENT_G_BIT,
+ eB = VK_COLOR_COMPONENT_B_BIT,
+ eA = VK_COLOR_COMPONENT_A_BIT
+ };
+
+ using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
+
+ VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
+ {
+ return ~( ColorComponentFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ColorComponentFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
+ };
+ };
+
+ struct PipelineColorBlendAttachmentState
+ {
+ PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0,
+ BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
+ BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
+ BlendOp colorBlendOp_ = BlendOp::eAdd,
+ BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
+ BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
+ BlendOp alphaBlendOp_ = BlendOp::eAdd,
+ ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
+ : blendEnable( blendEnable_ )
+ , srcColorBlendFactor( srcColorBlendFactor_ )
+ , dstColorBlendFactor( dstColorBlendFactor_ )
+ , colorBlendOp( colorBlendOp_ )
+ , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
+ , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
+ , alphaBlendOp( alphaBlendOp_ )
+ , colorWriteMask( colorWriteMask_ )
{
}
- SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
+ PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
}
- SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
+ PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
return *this;
}
- SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
+ PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
{
- buffer = buffer_;
+ blendEnable = blendEnable_;
return *this;
}
- SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
{
- bindCount = bindCount_;
+ srcColorBlendFactor = srcColorBlendFactor_;
return *this;
}
- SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
{
- pBinds = pBinds_;
+ dstColorBlendFactor = dstColorBlendFactor_;
return *this;
}
- operator const VkSparseBufferMemoryBindInfo&() const
- {
- return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
- }
-
- bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
- {
- return ( buffer == rhs.buffer )
- && ( bindCount == rhs.bindCount )
- && ( pBinds == rhs.pBinds );
- }
-
- bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- Buffer buffer;
- uint32_t bindCount;
- const SparseMemoryBind* pBinds;
- };
- static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
-
- struct SparseImageOpaqueMemoryBindInfo
- {
- SparseImageOpaqueMemoryBindInfo( Image image_ = Image(),
- uint32_t bindCount_ = 0,
- const SparseMemoryBind* pBinds_ = nullptr )
- : image( image_ )
- , bindCount( bindCount_ )
- , pBinds( pBinds_ )
+ PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
{
+ colorBlendOp = colorBlendOp_;
+ return *this;
}
- SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
{
- memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+ srcAlphaBlendFactor = srcAlphaBlendFactor_;
+ return *this;
}
- SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
{
- memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+ dstAlphaBlendFactor = dstAlphaBlendFactor_;
return *this;
}
- SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
+
+ PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
{
- image = image_;
+ alphaBlendOp = alphaBlendOp_;
return *this;
}
- SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
{
- bindCount = bindCount_;
+ colorWriteMask = colorWriteMask_;
return *this;
}
- SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ operator VkPipelineColorBlendAttachmentState const&() const
{
- pBinds = pBinds_;
- return *this;
+ return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
}
- operator const VkSparseImageOpaqueMemoryBindInfo&() const
+ operator VkPipelineColorBlendAttachmentState &()
{
- return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
+ return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this);
}
- bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
{
- return ( image == rhs.image )
- && ( bindCount == rhs.bindCount )
- && ( pBinds == rhs.pBinds );
+ return ( blendEnable == rhs.blendEnable )
+ && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
+ && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
+ && ( colorBlendOp == rhs.colorBlendOp )
+ && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
+ && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
+ && ( alphaBlendOp == rhs.alphaBlendOp )
+ && ( colorWriteMask == rhs.colorWriteMask );
}
- bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
{
return !operator==( rhs );
}
- Image image;
- uint32_t bindCount;
- const SparseMemoryBind* pBinds;
+ Bool32 blendEnable;
+ BlendFactor srcColorBlendFactor;
+ BlendFactor dstColorBlendFactor;
+ BlendOp colorBlendOp;
+ BlendFactor srcAlphaBlendFactor;
+ BlendFactor dstAlphaBlendFactor;
+ BlendOp alphaBlendOp;
+ ColorComponentFlags colorWriteMask;
};
- static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
- struct SparseImageMemoryBindInfo
+ struct PipelineColorBlendStateCreateInfo
{
- SparseImageMemoryBindInfo( Image image_ = Image(),
- uint32_t bindCount_ = 0,
- const SparseImageMemoryBind* pBinds_ = nullptr )
- : image( image_ )
- , bindCount( bindCount_ )
- , pBinds( pBinds_ )
+ PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(),
+ Bool32 logicOpEnable_ = 0,
+ LogicOp logicOp_ = LogicOp::eClear,
+ uint32_t attachmentCount_ = 0,
+ const PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
+ std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
+ : flags( flags_ )
+ , logicOpEnable( logicOpEnable_ )
+ , logicOp( logicOp_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
{
+ memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
}
- SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
+ PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
}
- SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
+ PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
return *this;
}
- SparseImageMemoryBindInfo& setImage( Image image_ )
+ PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
{
- image = image_;
+ pNext = pNext_;
return *this;
}
- SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
{
- bindCount = bindCount_;
+ flags = flags_;
return *this;
}
- SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
+ PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
{
- pBinds = pBinds_;
+ logicOpEnable = logicOpEnable_;
return *this;
}
- operator const VkSparseImageMemoryBindInfo&() const
+ PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
{
- return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
+ logicOp = logicOp_;
+ return *this;
}
- bool operator==( SparseImageMemoryBindInfo const& rhs ) const
+ PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
{
- return ( image == rhs.image )
- && ( bindCount == rhs.bindCount )
- && ( pBinds == rhs.pBinds );
+ attachmentCount = attachmentCount_;
+ return *this;
}
- bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
+ PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
{
- return !operator==( rhs );
+ pAttachments = pAttachments_;
+ return *this;
}
- Image image;
- uint32_t bindCount;
- const SparseImageMemoryBind* pBinds;
- };
- static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
-
- struct BindSparseInfo
- {
- BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
- const Semaphore* pWaitSemaphores_ = nullptr,
- uint32_t bufferBindCount_ = 0,
- const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
- uint32_t imageOpaqueBindCount_ = 0,
- const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
- uint32_t imageBindCount_ = 0,
- const SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
- uint32_t signalSemaphoreCount_ = 0,
- const Semaphore* pSignalSemaphores_ = nullptr )
- : waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , bufferBindCount( bufferBindCount_ )
- , pBufferBinds( pBufferBinds_ )
- , imageOpaqueBindCount( imageOpaqueBindCount_ )
- , pImageOpaqueBinds( pImageOpaqueBinds_ )
- , imageBindCount( imageBindCount_ )
- , pImageBinds( pImageBinds_ )
- , signalSemaphoreCount( signalSemaphoreCount_ )
- , pSignalSemaphores( pSignalSemaphores_ )
+ PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
{
+ memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
+ return *this;
}
- BindSparseInfo( VkBindSparseInfo const & rhs )
+ operator VkPipelineColorBlendStateCreateInfo const&() const
{
- memcpy( this, &rhs, sizeof( BindSparseInfo ) );
+ return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
}
- BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindSparseInfo ) );
- return *this;
- }
- BindSparseInfo& setPNext( const void* pNext_ )
+ operator VkPipelineColorBlendStateCreateInfo &()
{
- pNext = pNext_;
- return *this;
+ return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this);
}
- BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
{
- waitSemaphoreCount = waitSemaphoreCount_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( logicOpEnable == rhs.logicOpEnable )
+ && ( logicOp == rhs.logicOp )
+ && ( attachmentCount == rhs.attachmentCount )
+ && ( pAttachments == rhs.pAttachments )
+ && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
}
- BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
{
- pWaitSemaphores = pWaitSemaphores_;
- return *this;
+ return !operator==( rhs );
}
- BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
- {
- bufferBindCount = bufferBindCount_;
- return *this;
- }
+ private:
+ StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
- BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+ public:
+ const void* pNext = nullptr;
+ PipelineColorBlendStateCreateFlags flags;
+ Bool32 logicOpEnable;
+ LogicOp logicOp;
+ uint32_t attachmentCount;
+ const PipelineColorBlendAttachmentState* pAttachments;
+ float blendConstants[4];
+ };
+ static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
+
+ enum class FenceCreateFlagBits
+ {
+ eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
+ };
+
+ using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
+
+ VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+ {
+ return FenceCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
+ {
+ return ~( FenceCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<FenceCreateFlagBits>
+ {
+ enum
{
- pBufferBinds = pBufferBinds_;
- return *this;
- }
+ allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
+ };
+ };
- BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
+ struct FenceCreateInfo
+ {
+ FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
+ : flags( flags_ )
{
- imageOpaqueBindCount = imageOpaqueBindCount_;
- return *this;
}
- BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+ FenceCreateInfo( VkFenceCreateInfo const & rhs )
{
- pImageOpaqueBinds = pImageOpaqueBinds_;
- return *this;
+ memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
}
- BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
+ FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
{
- imageBindCount = imageBindCount_;
+ memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
return *this;
}
-
- BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+ FenceCreateInfo& setPNext( const void* pNext_ )
{
- pImageBinds = pImageBinds_;
+ pNext = pNext_;
return *this;
}
- BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+ FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
{
- signalSemaphoreCount = signalSemaphoreCount_;
+ flags = flags_;
return *this;
}
- BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+ operator VkFenceCreateInfo const&() const
{
- pSignalSemaphores = pSignalSemaphores_;
- return *this;
+ return *reinterpret_cast<const VkFenceCreateInfo*>(this);
}
- operator const VkBindSparseInfo&() const
+ operator VkFenceCreateInfo &()
{
- return *reinterpret_cast<const VkBindSparseInfo*>(this);
+ return *reinterpret_cast<VkFenceCreateInfo*>(this);
}
- bool operator==( BindSparseInfo const& rhs ) const
+ bool operator==( FenceCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
- && ( pWaitSemaphores == rhs.pWaitSemaphores )
- && ( bufferBindCount == rhs.bufferBindCount )
- && ( pBufferBinds == rhs.pBufferBinds )
- && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
- && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
- && ( imageBindCount == rhs.imageBindCount )
- && ( pImageBinds == rhs.pImageBinds )
- && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
- && ( pSignalSemaphores == rhs.pSignalSemaphores );
+ && ( flags == rhs.flags );
}
- bool operator!=( BindSparseInfo const& rhs ) const
+ bool operator!=( FenceCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eBindSparseInfo;
+ StructureType sType = StructureType::eFenceCreateInfo;
public:
const void* pNext = nullptr;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- uint32_t bufferBindCount;
- const SparseBufferMemoryBindInfo* pBufferBinds;
- uint32_t imageOpaqueBindCount;
- const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
- uint32_t imageBindCount;
- const SparseImageMemoryBindInfo* pImageBinds;
- uint32_t signalSemaphoreCount;
- const Semaphore* pSignalSemaphores;
+ FenceCreateFlags flags;
};
- static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
- enum class PipelineStageFlagBits
+ enum class FormatFeatureFlagBits
{
- eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
- eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
- eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
- eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
- eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
- eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
- eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
- eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
- eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
- eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
- eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
- eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
- eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
- eHost = VK_PIPELINE_STAGE_HOST_BIT,
- eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
- eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
- eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
+ eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
+ eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
+ eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
+ eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
+ eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
+ eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
+ eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
+ eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
+ eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
+ eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
+ eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
+ eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
+ eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
+ eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
+ eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
+ eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
+ eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
+ eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
+ eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
+ eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
+ eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
+ eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
+ eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
+ eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
+ eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
+ eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
+ eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
+ eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT,
+ eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
+ eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
+ eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
+ eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
+ eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT
};
- using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
+ using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
- VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
{
- return PipelineStageFlags( bit0 ) | bit1;
+ return FormatFeatureFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
+ VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
{
- return ~( PipelineStageFlags( bits ) );
+ return ~( FormatFeatureFlags( bits ) );
}
- template <> struct FlagTraits<PipelineStageFlagBits>
+ template <> struct FlagTraits<FormatFeatureFlagBits>
{
enum
{
- allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX)
+ allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT)
};
};
- struct QueueFamilyCheckpointPropertiesNV
+ struct FormatProperties
{
- operator const VkQueueFamilyCheckpointPropertiesNV&() const
+ operator VkFormatProperties const&() const
{
- return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(this);
+ return *reinterpret_cast<const VkFormatProperties*>(this);
}
- bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const
+ operator VkFormatProperties &()
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+ return *reinterpret_cast<VkFormatProperties*>(this);
}
- bool operator!=( QueueFamilyCheckpointPropertiesNV const& rhs ) const
+ bool operator==( FormatProperties const& rhs ) const
{
- return !operator==( rhs );
+ return ( linearTilingFeatures == rhs.linearTilingFeatures )
+ && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
+ && ( bufferFeatures == rhs.bufferFeatures );
}
- private:
- StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+ bool operator!=( FormatProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- public:
- void* pNext = nullptr;
- PipelineStageFlags checkpointExecutionStageMask;
+ FormatFeatureFlags linearTilingFeatures;
+ FormatFeatureFlags optimalTilingFeatures;
+ FormatFeatureFlags bufferFeatures;
};
- static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
- struct CheckpointDataNV
+ struct FormatProperties2
{
- operator const VkCheckpointDataNV&() const
+ operator VkFormatProperties2 const&() const
{
- return *reinterpret_cast<const VkCheckpointDataNV*>(this);
+ return *reinterpret_cast<const VkFormatProperties2*>(this);
}
- bool operator==( CheckpointDataNV const& rhs ) const
+ operator VkFormatProperties2 &()
+ {
+ return *reinterpret_cast<VkFormatProperties2*>(this);
+ }
+
+ bool operator==( FormatProperties2 const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( stage == rhs.stage )
- && ( pCheckpointMarker == rhs.pCheckpointMarker );
+ && ( formatProperties == rhs.formatProperties );
}
- bool operator!=( CheckpointDataNV const& rhs ) const
+ bool operator!=( FormatProperties2 const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eCheckpointDataNV;
+ StructureType sType = StructureType::eFormatProperties2;
public:
void* pNext = nullptr;
- PipelineStageFlagBits stage;
- void* pCheckpointMarker;
- };
- static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
-
- enum class CommandPoolCreateFlagBits
- {
- eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
- eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
- eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT
+ FormatProperties formatProperties;
};
+ static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
- using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
+ using FormatProperties2KHR = FormatProperties2;
- VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ struct DrmFormatModifierPropertiesEXT
{
- return CommandPoolCreateFlags( bit0 ) | bit1;
- }
+ operator VkDrmFormatModifierPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>(this);
+ }
- VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
- {
- return ~( CommandPoolCreateFlags( bits ) );
- }
+ operator VkDrmFormatModifierPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this);
+ }
- template <> struct FlagTraits<CommandPoolCreateFlagBits>
- {
- enum
+ bool operator==( DrmFormatModifierPropertiesEXT const& rhs ) const
{
- allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) | VkFlags(CommandPoolCreateFlagBits::eProtected)
- };
+ return ( drmFormatModifier == rhs.drmFormatModifier )
+ && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount )
+ && ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+ }
+
+ bool operator!=( DrmFormatModifierPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint64_t drmFormatModifier;
+ uint32_t drmFormatModifierPlaneCount;
+ FormatFeatureFlags drmFormatModifierTilingFeatures;
};
+ static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
- struct CommandPoolCreateInfo
+ struct DrmFormatModifierPropertiesListEXT
{
- CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(),
- uint32_t queueFamilyIndex_ = 0 )
- : flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
+ DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0,
+ DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr )
+ : drmFormatModifierCount( drmFormatModifierCount_ )
+ , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
{
}
- CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+ DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
}
- CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+ DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
return *this;
}
- CommandPoolCreateInfo& setPNext( const void* pNext_ )
+ DrmFormatModifierPropertiesListEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
+ DrmFormatModifierPropertiesListEXT& setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ )
{
- flags = flags_;
+ drmFormatModifierCount = drmFormatModifierCount_;
return *this;
}
- CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+ DrmFormatModifierPropertiesListEXT& setPDrmFormatModifierProperties( DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ )
{
- queueFamilyIndex = queueFamilyIndex_;
+ pDrmFormatModifierProperties = pDrmFormatModifierProperties_;
return *this;
}
- operator const VkCommandPoolCreateInfo&() const
+ operator VkDrmFormatModifierPropertiesListEXT const&() const
{
- return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
+ return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(this);
}
- bool operator==( CommandPoolCreateInfo const& rhs ) const
+ operator VkDrmFormatModifierPropertiesListEXT &()
+ {
+ return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this);
+ }
+
+ bool operator==( DrmFormatModifierPropertiesListEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( queueFamilyIndex == rhs.queueFamilyIndex );
+ && ( drmFormatModifierCount == rhs.drmFormatModifierCount )
+ && ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
}
- bool operator!=( CommandPoolCreateInfo const& rhs ) const
+ bool operator!=( DrmFormatModifierPropertiesListEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eCommandPoolCreateInfo;
+ StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
public:
- const void* pNext = nullptr;
- CommandPoolCreateFlags flags;
- uint32_t queueFamilyIndex;
+ void* pNext = nullptr;
+ uint32_t drmFormatModifierCount;
+ DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
};
- static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
- enum class CommandPoolResetFlagBits
+ enum class QueryControlFlagBits
{
- eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
+ ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
};
- using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
+ using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
- VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
{
- return CommandPoolResetFlags( bit0 ) | bit1;
+ return QueryControlFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
+ VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
{
- return ~( CommandPoolResetFlags( bits ) );
+ return ~( QueryControlFlags( bits ) );
}
- template <> struct FlagTraits<CommandPoolResetFlagBits>
+ template <> struct FlagTraits<QueryControlFlagBits>
{
enum
{
- allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
+ allFlags = VkFlags(QueryControlFlagBits::ePrecise)
};
};
- enum class CommandBufferResetFlagBits
+ enum class QueryResultFlagBits
{
- eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+ e64 = VK_QUERY_RESULT_64_BIT,
+ eWait = VK_QUERY_RESULT_WAIT_BIT,
+ eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
+ ePartial = VK_QUERY_RESULT_PARTIAL_BIT
};
- using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
+ using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
- VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
{
- return CommandBufferResetFlags( bit0 ) | bit1;
+ return QueryResultFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+ VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
{
- return ~( CommandBufferResetFlags( bits ) );
+ return ~( QueryResultFlags( bits ) );
}
- template <> struct FlagTraits<CommandBufferResetFlagBits>
+ template <> struct FlagTraits<QueryResultFlagBits>
{
enum
{
- allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
+ allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
};
};
- enum class SampleCountFlagBits
+ enum class CommandBufferUsageFlagBits
{
- e1 = VK_SAMPLE_COUNT_1_BIT,
- e2 = VK_SAMPLE_COUNT_2_BIT,
- e4 = VK_SAMPLE_COUNT_4_BIT,
- e8 = VK_SAMPLE_COUNT_8_BIT,
- e16 = VK_SAMPLE_COUNT_16_BIT,
- e32 = VK_SAMPLE_COUNT_32_BIT,
- e64 = VK_SAMPLE_COUNT_64_BIT
+ eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+ eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
+ eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
};
- using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
+ using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
- VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
{
- return SampleCountFlags( bit0 ) | bit1;
+ return CommandBufferUsageFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
+ VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
{
- return ~( SampleCountFlags( bits ) );
+ return ~( CommandBufferUsageFlags( bits ) );
}
- template <> struct FlagTraits<SampleCountFlagBits>
+ template <> struct FlagTraits<CommandBufferUsageFlagBits>
{
enum
{
- allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
+ allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
};
};
- struct ImageFormatProperties
+ enum class QueryPipelineStatisticFlagBits
{
- operator const VkImageFormatProperties&() const
- {
- return *reinterpret_cast<const VkImageFormatProperties*>(this);
- }
+ eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
+ eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
+ eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
+ eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
+ eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
+ eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
+ eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
+ eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
+ eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
+ eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
+ eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
+ };
- bool operator==( ImageFormatProperties const& rhs ) const
- {
- return ( maxExtent == rhs.maxExtent )
- && ( maxMipLevels == rhs.maxMipLevels )
- && ( maxArrayLayers == rhs.maxArrayLayers )
- && ( sampleCounts == rhs.sampleCounts )
- && ( maxResourceSize == rhs.maxResourceSize );
- }
+ using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
- bool operator!=( ImageFormatProperties const& rhs ) const
- {
- return !operator==( rhs );
- }
+ VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+ {
+ return QueryPipelineStatisticFlags( bit0 ) | bit1;
+ }
- Extent3D maxExtent;
- uint32_t maxMipLevels;
- uint32_t maxArrayLayers;
- SampleCountFlags sampleCounts;
- DeviceSize maxResourceSize;
+ VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
+ {
+ return ~( QueryPipelineStatisticFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
+ };
};
- static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
- struct ImageCreateInfo
+ struct CommandBufferInheritanceInfo
{
- ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(),
- ImageType imageType_ = ImageType::e1D,
- Format format_ = Format::eUndefined,
- Extent3D extent_ = Extent3D(),
- uint32_t mipLevels_ = 0,
- uint32_t arrayLayers_ = 0,
- SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
- ImageTiling tiling_ = ImageTiling::eOptimal,
- ImageUsageFlags usage_ = ImageUsageFlags(),
- SharingMode sharingMode_ = SharingMode::eExclusive,
- uint32_t queueFamilyIndexCount_ = 0,
- const uint32_t* pQueueFamilyIndices_ = nullptr,
- ImageLayout initialLayout_ = ImageLayout::eUndefined )
- : flags( flags_ )
- , imageType( imageType_ )
- , format( format_ )
- , extent( extent_ )
- , mipLevels( mipLevels_ )
- , arrayLayers( arrayLayers_ )
- , samples( samples_ )
- , tiling( tiling_ )
- , usage( usage_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
- , initialLayout( initialLayout_ )
+ CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(),
+ uint32_t subpass_ = 0,
+ Framebuffer framebuffer_ = Framebuffer(),
+ Bool32 occlusionQueryEnable_ = 0,
+ QueryControlFlags queryFlags_ = QueryControlFlags(),
+ QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
+ : renderPass( renderPass_ )
+ , subpass( subpass_ )
+ , framebuffer( framebuffer_ )
+ , occlusionQueryEnable( occlusionQueryEnable_ )
+ , queryFlags( queryFlags_ )
+ , pipelineStatistics( pipelineStatistics_ )
{
}
- ImageCreateInfo( VkImageCreateInfo const & rhs )
+ CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
}
- ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+ CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
return *this;
}
- ImageCreateInfo& setPNext( const void* pNext_ )
+ CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
+ CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
{
- flags = flags_;
+ renderPass = renderPass_;
return *this;
}
- ImageCreateInfo& setImageType( ImageType imageType_ )
+ CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
{
- imageType = imageType_;
+ subpass = subpass_;
return *this;
}
- ImageCreateInfo& setFormat( Format format_ )
+ CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
{
- format = format_;
+ framebuffer = framebuffer_;
return *this;
}
- ImageCreateInfo& setExtent( Extent3D extent_ )
+ CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
{
- extent = extent_;
+ occlusionQueryEnable = occlusionQueryEnable_;
return *this;
}
- ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
+ CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
{
- mipLevels = mipLevels_;
+ queryFlags = queryFlags_;
return *this;
}
- ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
+ CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
{
- arrayLayers = arrayLayers_;
+ pipelineStatistics = pipelineStatistics_;
return *this;
}
- ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
+ operator VkCommandBufferInheritanceInfo const&() const
{
- samples = samples_;
- return *this;
+ return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
}
- ImageCreateInfo& setTiling( ImageTiling tiling_ )
+ operator VkCommandBufferInheritanceInfo &()
{
- tiling = tiling_;
- return *this;
+ return *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this);
}
- ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
+ bool operator==( CommandBufferInheritanceInfo const& rhs ) const
{
- usage = usage_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( renderPass == rhs.renderPass )
+ && ( subpass == rhs.subpass )
+ && ( framebuffer == rhs.framebuffer )
+ && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
+ && ( queryFlags == rhs.queryFlags )
+ && ( pipelineStatistics == rhs.pipelineStatistics );
}
- ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
+ bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
{
- sharingMode = sharingMode_;
- return *this;
+ return !operator==( rhs );
}
- ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ private:
+ StructureType sType = StructureType::eCommandBufferInheritanceInfo;
+
+ public:
+ const void* pNext = nullptr;
+ RenderPass renderPass;
+ uint32_t subpass;
+ Framebuffer framebuffer;
+ Bool32 occlusionQueryEnable;
+ QueryControlFlags queryFlags;
+ QueryPipelineStatisticFlags pipelineStatistics;
+ };
+ static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
+
+ struct CommandBufferBeginInfo
+ {
+ CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(),
+ const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+ : flags( flags_ )
+ , pInheritanceInfo( pInheritanceInfo_ )
{
- queueFamilyIndexCount = queueFamilyIndexCount_;
+ }
+
+ CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+ }
+
+ CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+ return *this;
+ }
+ CommandBufferBeginInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
{
- pQueueFamilyIndices = pQueueFamilyIndices_;
+ flags = flags_;
return *this;
}
- ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
+ CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
{
- initialLayout = initialLayout_;
+ pInheritanceInfo = pInheritanceInfo_;
return *this;
}
- operator const VkImageCreateInfo&() const
+ operator VkCommandBufferBeginInfo const&() const
{
- return *reinterpret_cast<const VkImageCreateInfo*>(this);
+ return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
}
- bool operator==( ImageCreateInfo const& rhs ) const
+ operator VkCommandBufferBeginInfo &()
+ {
+ return *reinterpret_cast<VkCommandBufferBeginInfo*>(this);
+ }
+
+ bool operator==( CommandBufferBeginInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( imageType == rhs.imageType )
- && ( format == rhs.format )
- && ( extent == rhs.extent )
- && ( mipLevels == rhs.mipLevels )
- && ( arrayLayers == rhs.arrayLayers )
- && ( samples == rhs.samples )
- && ( tiling == rhs.tiling )
- && ( usage == rhs.usage )
- && ( sharingMode == rhs.sharingMode )
- && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
- && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
- && ( initialLayout == rhs.initialLayout );
+ && ( pInheritanceInfo == rhs.pInheritanceInfo );
}
- bool operator!=( ImageCreateInfo const& rhs ) const
+ bool operator!=( CommandBufferBeginInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImageCreateInfo;
+ StructureType sType = StructureType::eCommandBufferBeginInfo;
public:
const void* pNext = nullptr;
- ImageCreateFlags flags;
- ImageType imageType;
- Format format;
- Extent3D extent;
- uint32_t mipLevels;
- uint32_t arrayLayers;
- SampleCountFlagBits samples;
- ImageTiling tiling;
- ImageUsageFlags usage;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- ImageLayout initialLayout;
+ CommandBufferUsageFlags flags;
+ const CommandBufferInheritanceInfo* pInheritanceInfo;
};
- static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
- struct PipelineMultisampleStateCreateInfo
+ struct QueryPoolCreateInfo
{
- PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(),
- SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1,
- Bool32 sampleShadingEnable_ = 0,
- float minSampleShading_ = 0,
- const SampleMask* pSampleMask_ = nullptr,
- Bool32 alphaToCoverageEnable_ = 0,
- Bool32 alphaToOneEnable_ = 0 )
+ QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(),
+ QueryType queryType_ = QueryType::eOcclusion,
+ uint32_t queryCount_ = 0,
+ QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
: flags( flags_ )
- , rasterizationSamples( rasterizationSamples_ )
- , sampleShadingEnable( sampleShadingEnable_ )
- , minSampleShading( minSampleShading_ )
- , pSampleMask( pSampleMask_ )
- , alphaToCoverageEnable( alphaToCoverageEnable_ )
- , alphaToOneEnable( alphaToOneEnable_ )
+ , queryType( queryType_ )
+ , queryCount( queryCount_ )
+ , pipelineStatistics( pipelineStatistics_ )
{
}
- PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+ QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
}
- PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+ QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
return *this;
}
- PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
+ QueryPoolCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
+ QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
- {
- rasterizationSamples = rasterizationSamples_;
- return *this;
- }
-
- PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
- {
- sampleShadingEnable = sampleShadingEnable_;
- return *this;
- }
-
- PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
+ QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
{
- minSampleShading = minSampleShading_;
+ queryType = queryType_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
+ QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
{
- pSampleMask = pSampleMask_;
+ queryCount = queryCount_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+ QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
{
- alphaToCoverageEnable = alphaToCoverageEnable_;
+ pipelineStatistics = pipelineStatistics_;
return *this;
}
- PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+ operator VkQueryPoolCreateInfo const&() const
{
- alphaToOneEnable = alphaToOneEnable_;
- return *this;
+ return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
}
- operator const VkPipelineMultisampleStateCreateInfo&() const
+ operator VkQueryPoolCreateInfo &()
{
- return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
+ return *reinterpret_cast<VkQueryPoolCreateInfo*>(this);
}
- bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
+ bool operator==( QueryPoolCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( rasterizationSamples == rhs.rasterizationSamples )
- && ( sampleShadingEnable == rhs.sampleShadingEnable )
- && ( minSampleShading == rhs.minSampleShading )
- && ( pSampleMask == rhs.pSampleMask )
- && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
- && ( alphaToOneEnable == rhs.alphaToOneEnable );
+ && ( queryType == rhs.queryType )
+ && ( queryCount == rhs.queryCount )
+ && ( pipelineStatistics == rhs.pipelineStatistics );
}
- bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
+ bool operator!=( QueryPoolCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
+ StructureType sType = StructureType::eQueryPoolCreateInfo;
public:
const void* pNext = nullptr;
- PipelineMultisampleStateCreateFlags flags;
- SampleCountFlagBits rasterizationSamples;
- Bool32 sampleShadingEnable;
- float minSampleShading;
- const SampleMask* pSampleMask;
- Bool32 alphaToCoverageEnable;
- Bool32 alphaToOneEnable;
+ QueryPoolCreateFlags flags;
+ QueryType queryType;
+ uint32_t queryCount;
+ QueryPipelineStatisticFlags pipelineStatistics;
};
- static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
- struct GraphicsPipelineCreateInfo
+ enum class ImageAspectFlagBits
{
- GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
- uint32_t stageCount_ = 0,
- const PipelineShaderStageCreateInfo* pStages_ = nullptr,
- const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
- const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
- const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
- const PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
- const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
- const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
- const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
- const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
- const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
- PipelineLayout layout_ = PipelineLayout(),
- RenderPass renderPass_ = RenderPass(),
- uint32_t subpass_ = 0,
- Pipeline basePipelineHandle_ = Pipeline(),
- int32_t basePipelineIndex_ = 0 )
- : flags( flags_ )
- , stageCount( stageCount_ )
- , pStages( pStages_ )
- , pVertexInputState( pVertexInputState_ )
- , pInputAssemblyState( pInputAssemblyState_ )
- , pTessellationState( pTessellationState_ )
- , pViewportState( pViewportState_ )
- , pRasterizationState( pRasterizationState_ )
- , pMultisampleState( pMultisampleState_ )
- , pDepthStencilState( pDepthStencilState_ )
- , pColorBlendState( pColorBlendState_ )
- , pDynamicState( pDynamicState_ )
- , layout( layout_ )
- , renderPass( renderPass_ )
- , subpass( subpass_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
+ eColor = VK_IMAGE_ASPECT_COLOR_BIT,
+ eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
+ eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
+ eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
+ ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
+ ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
+ ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
+ ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
+ ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
+ ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
+ eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
+ eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
+ eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
+ eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT
+ };
+
+ using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
+
+ VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
+ {
+ return ~( ImageAspectFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ImageAspectFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0) | VkFlags(ImageAspectFlagBits::ePlane1) | VkFlags(ImageAspectFlagBits::ePlane2) | VkFlags(ImageAspectFlagBits::eMemoryPlane0EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane1EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane2EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane3EXT)
+ };
+ };
+
+ struct ImageSubresource
+ {
+ ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+ uint32_t mipLevel_ = 0,
+ uint32_t arrayLayer_ = 0 )
+ : aspectMask( aspectMask_ )
+ , mipLevel( mipLevel_ )
+ , arrayLayer( arrayLayer_ )
{
}
- GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
+ ImageSubresource( VkImageSubresource const & rhs )
{
- memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ImageSubresource ) );
}
- GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
+ ImageSubresource& operator=( VkImageSubresource const & rhs )
{
- memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ImageSubresource ) );
return *this;
}
- GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
+ ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
{
- pNext = pNext_;
+ aspectMask = aspectMask_;
return *this;
}
- GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
+ ImageSubresource& setMipLevel( uint32_t mipLevel_ )
{
- flags = flags_;
+ mipLevel = mipLevel_;
return *this;
}
- GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
+ ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
{
- stageCount = stageCount_;
+ arrayLayer = arrayLayer_;
return *this;
}
- GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+ operator VkImageSubresource const&() const
{
- pStages = pStages_;
- return *this;
+ return *reinterpret_cast<const VkImageSubresource*>(this);
}
- GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
+ operator VkImageSubresource &()
{
- pVertexInputState = pVertexInputState_;
- return *this;
+ return *reinterpret_cast<VkImageSubresource*>(this);
}
- GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+ bool operator==( ImageSubresource const& rhs ) const
{
- pInputAssemblyState = pInputAssemblyState_;
- return *this;
+ return ( aspectMask == rhs.aspectMask )
+ && ( mipLevel == rhs.mipLevel )
+ && ( arrayLayer == rhs.arrayLayer );
}
- GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+ bool operator!=( ImageSubresource const& rhs ) const
{
- pTessellationState = pTessellationState_;
- return *this;
+ return !operator==( rhs );
}
- GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+ ImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t arrayLayer;
+ };
+ static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
+
+ struct ImageSubresourceLayers
+ {
+ ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+ uint32_t mipLevel_ = 0,
+ uint32_t baseArrayLayer_ = 0,
+ uint32_t layerCount_ = 0 )
+ : aspectMask( aspectMask_ )
+ , mipLevel( mipLevel_ )
+ , baseArrayLayer( baseArrayLayer_ )
+ , layerCount( layerCount_ )
{
- pViewportState = pViewportState_;
- return *this;
}
- GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+ ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
{
- pRasterizationState = pRasterizationState_;
- return *this;
+ memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
}
- GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+ ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
{
- pMultisampleState = pMultisampleState_;
+ memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
return *this;
}
-
- GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+ ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
{
- pDepthStencilState = pDepthStencilState_;
+ aspectMask = aspectMask_;
return *this;
}
- GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+ ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
{
- pColorBlendState = pColorBlendState_;
+ mipLevel = mipLevel_;
+ return *this;
+ }
+
+ ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
+ {
+ baseArrayLayer = baseArrayLayer_;
+ return *this;
+ }
+
+ ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
+ {
+ layerCount = layerCount_;
+ return *this;
+ }
+
+ operator VkImageSubresourceLayers const&() const
+ {
+ return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
+ }
+
+ operator VkImageSubresourceLayers &()
+ {
+ return *reinterpret_cast<VkImageSubresourceLayers*>(this);
+ }
+
+ bool operator==( ImageSubresourceLayers const& rhs ) const
+ {
+ return ( aspectMask == rhs.aspectMask )
+ && ( mipLevel == rhs.mipLevel )
+ && ( baseArrayLayer == rhs.baseArrayLayer )
+ && ( layerCount == rhs.layerCount );
+ }
+
+ bool operator!=( ImageSubresourceLayers const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+ };
+ static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
+
+ struct ImageSubresourceRange
+ {
+ ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+ uint32_t baseMipLevel_ = 0,
+ uint32_t levelCount_ = 0,
+ uint32_t baseArrayLayer_ = 0,
+ uint32_t layerCount_ = 0 )
+ : aspectMask( aspectMask_ )
+ , baseMipLevel( baseMipLevel_ )
+ , levelCount( levelCount_ )
+ , baseArrayLayer( baseArrayLayer_ )
+ , layerCount( layerCount_ )
+ {
+ }
+
+ ImageSubresourceRange( VkImageSubresourceRange const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+ }
+
+ ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+ return *this;
+ }
+ ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
+ {
+ aspectMask = aspectMask_;
+ return *this;
+ }
+
+ ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
+ {
+ baseMipLevel = baseMipLevel_;
+ return *this;
+ }
+
+ ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
+ {
+ levelCount = levelCount_;
+ return *this;
+ }
+
+ ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
+ {
+ baseArrayLayer = baseArrayLayer_;
+ return *this;
+ }
+
+ ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
+ {
+ layerCount = layerCount_;
+ return *this;
+ }
+
+ operator VkImageSubresourceRange const&() const
+ {
+ return *reinterpret_cast<const VkImageSubresourceRange*>(this);
+ }
+
+ operator VkImageSubresourceRange &()
+ {
+ return *reinterpret_cast<VkImageSubresourceRange*>(this);
+ }
+
+ bool operator==( ImageSubresourceRange const& rhs ) const
+ {
+ return ( aspectMask == rhs.aspectMask )
+ && ( baseMipLevel == rhs.baseMipLevel )
+ && ( levelCount == rhs.levelCount )
+ && ( baseArrayLayer == rhs.baseArrayLayer )
+ && ( layerCount == rhs.layerCount );
+ }
+
+ bool operator!=( ImageSubresourceRange const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t baseMipLevel;
+ uint32_t levelCount;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+ };
+ static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
+
+ struct ImageMemoryBarrier
+ {
+ ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
+ AccessFlags dstAccessMask_ = AccessFlags(),
+ ImageLayout oldLayout_ = ImageLayout::eUndefined,
+ ImageLayout newLayout_ = ImageLayout::eUndefined,
+ uint32_t srcQueueFamilyIndex_ = 0,
+ uint32_t dstQueueFamilyIndex_ = 0,
+ Image image_ = Image(),
+ ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
+ : srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , oldLayout( oldLayout_ )
+ , newLayout( newLayout_ )
+ , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+ , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+ , image( image_ )
+ , subresourceRange( subresourceRange_ )
+ {
+ }
+
+ ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+ }
+
+ ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+ return *this;
+ }
+ ImageMemoryBarrier& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ {
+ srcAccessMask = srcAccessMask_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
+ {
+ dstAccessMask = dstAccessMask_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
+ {
+ oldLayout = oldLayout_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
+ {
+ newLayout = newLayout_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+ {
+ srcQueueFamilyIndex = srcQueueFamilyIndex_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+ {
+ dstQueueFamilyIndex = dstQueueFamilyIndex_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ {
+ subresourceRange = subresourceRange_;
+ return *this;
+ }
+
+ operator VkImageMemoryBarrier const&() const
+ {
+ return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
+ }
+
+ operator VkImageMemoryBarrier &()
+ {
+ return *reinterpret_cast<VkImageMemoryBarrier*>(this);
+ }
+
+ bool operator==( ImageMemoryBarrier const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( oldLayout == rhs.oldLayout )
+ && ( newLayout == rhs.newLayout )
+ && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
+ && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
+ && ( image == rhs.image )
+ && ( subresourceRange == rhs.subresourceRange );
+ }
+
+ bool operator!=( ImageMemoryBarrier const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eImageMemoryBarrier;
+
+ public:
+ const void* pNext = nullptr;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ ImageLayout oldLayout;
+ ImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ Image image;
+ ImageSubresourceRange subresourceRange;
+ };
+ static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
+
+ struct ImageViewCreateInfo
+ {
+ ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(),
+ Image image_ = Image(),
+ ImageViewType viewType_ = ImageViewType::e1D,
+ Format format_ = Format::eUndefined,
+ ComponentMapping components_ = ComponentMapping(),
+ ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
+ : flags( flags_ )
+ , image( image_ )
+ , viewType( viewType_ )
+ , format( format_ )
+ , components( components_ )
+ , subresourceRange( subresourceRange_ )
+ {
+ }
+
+ ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+ }
+
+ ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+ return *this;
+ }
+ ImageViewCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
+ {
+ viewType = viewType_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setComponents( ComponentMapping components_ )
+ {
+ components = components_;
+ return *this;
+ }
+
+ ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ {
+ subresourceRange = subresourceRange_;
+ return *this;
+ }
+
+ operator VkImageViewCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
+ }
+
+ operator VkImageViewCreateInfo &()
+ {
+ return *reinterpret_cast<VkImageViewCreateInfo*>(this);
+ }
+
+ bool operator==( ImageViewCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( image == rhs.image )
+ && ( viewType == rhs.viewType )
+ && ( format == rhs.format )
+ && ( components == rhs.components )
+ && ( subresourceRange == rhs.subresourceRange );
+ }
+
+ bool operator!=( ImageViewCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eImageViewCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ ImageViewCreateFlags flags;
+ Image image;
+ ImageViewType viewType;
+ Format format;
+ ComponentMapping components;
+ ImageSubresourceRange subresourceRange;
+ };
+ static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
+
+ struct ImageCopy
+ {
+ ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
+ Offset3D srcOffset_ = Offset3D(),
+ ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
+ Offset3D dstOffset_ = Offset3D(),
+ Extent3D extent_ = Extent3D() )
+ : srcSubresource( srcSubresource_ )
+ , srcOffset( srcOffset_ )
+ , dstSubresource( dstSubresource_ )
+ , dstOffset( dstOffset_ )
+ , extent( extent_ )
+ {
+ }
+
+ ImageCopy( VkImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageCopy ) );
+ }
+
+ ImageCopy& operator=( VkImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageCopy ) );
+ return *this;
+ }
+ ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ {
+ srcSubresource = srcSubresource_;
+ return *this;
+ }
+
+ ImageCopy& setSrcOffset( Offset3D srcOffset_ )
+ {
+ srcOffset = srcOffset_;
+ return *this;
+ }
+
+ ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ {
+ dstSubresource = dstSubresource_;
+ return *this;
+ }
+
+ ImageCopy& setDstOffset( Offset3D dstOffset_ )
+ {
+ dstOffset = dstOffset_;
+ return *this;
+ }
+
+ ImageCopy& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ operator VkImageCopy const&() const
+ {
+ return *reinterpret_cast<const VkImageCopy*>(this);
+ }
+
+ operator VkImageCopy &()
+ {
+ return *reinterpret_cast<VkImageCopy*>(this);
+ }
+
+ bool operator==( ImageCopy const& rhs ) const
+ {
+ return ( srcSubresource == rhs.srcSubresource )
+ && ( srcOffset == rhs.srcOffset )
+ && ( dstSubresource == rhs.dstSubresource )
+ && ( dstOffset == rhs.dstOffset )
+ && ( extent == rhs.extent );
+ }
+
+ bool operator!=( ImageCopy const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresourceLayers srcSubresource;
+ Offset3D srcOffset;
+ ImageSubresourceLayers dstSubresource;
+ Offset3D dstOffset;
+ Extent3D extent;
+ };
+ static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
+
+ struct ImageBlit
+ {
+ ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
+ std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } },
+ ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
+ std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
+ : srcSubresource( srcSubresource_ )
+ , dstSubresource( dstSubresource_ )
+ {
+ memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+ memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ }
+
+ ImageBlit( VkImageBlit const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageBlit ) );
+ }
+
+ ImageBlit& operator=( VkImageBlit const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageBlit ) );
+ return *this;
+ }
+ ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ {
+ srcSubresource = srcSubresource_;
+ return *this;
+ }
+
+ ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+ {
+ memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+ return *this;
+ }
+
+ ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ {
+ dstSubresource = dstSubresource_;
+ return *this;
+ }
+
+ ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+ {
+ memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ return *this;
+ }
+
+ operator VkImageBlit const&() const
+ {
+ return *reinterpret_cast<const VkImageBlit*>(this);
+ }
+
+ operator VkImageBlit &()
+ {
+ return *reinterpret_cast<VkImageBlit*>(this);
+ }
+
+ bool operator==( ImageBlit const& rhs ) const
+ {
+ return ( srcSubresource == rhs.srcSubresource )
+ && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
+ && ( dstSubresource == rhs.dstSubresource )
+ && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+ }
+
+ bool operator!=( ImageBlit const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresourceLayers srcSubresource;
+ Offset3D srcOffsets[2];
+ ImageSubresourceLayers dstSubresource;
+ Offset3D dstOffsets[2];
+ };
+ static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
+
+ struct BufferImageCopy
+ {
+ BufferImageCopy( DeviceSize bufferOffset_ = 0,
+ uint32_t bufferRowLength_ = 0,
+ uint32_t bufferImageHeight_ = 0,
+ ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
+ Offset3D imageOffset_ = Offset3D(),
+ Extent3D imageExtent_ = Extent3D() )
+ : bufferOffset( bufferOffset_ )
+ , bufferRowLength( bufferRowLength_ )
+ , bufferImageHeight( bufferImageHeight_ )
+ , imageSubresource( imageSubresource_ )
+ , imageOffset( imageOffset_ )
+ , imageExtent( imageExtent_ )
+ {
+ }
+
+ BufferImageCopy( VkBufferImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( BufferImageCopy ) );
+ }
+
+ BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( BufferImageCopy ) );
+ return *this;
+ }
+ BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
+ {
+ bufferOffset = bufferOffset_;
+ return *this;
+ }
+
+ BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
+ {
+ bufferRowLength = bufferRowLength_;
+ return *this;
+ }
+
+ BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
+ {
+ bufferImageHeight = bufferImageHeight_;
+ return *this;
+ }
+
+ BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+ {
+ imageSubresource = imageSubresource_;
+ return *this;
+ }
+
+ BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
+ {
+ imageOffset = imageOffset_;
+ return *this;
+ }
+
+ BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
+ {
+ imageExtent = imageExtent_;
+ return *this;
+ }
+
+ operator VkBufferImageCopy const&() const
+ {
+ return *reinterpret_cast<const VkBufferImageCopy*>(this);
+ }
+
+ operator VkBufferImageCopy &()
+ {
+ return *reinterpret_cast<VkBufferImageCopy*>(this);
+ }
+
+ bool operator==( BufferImageCopy const& rhs ) const
+ {
+ return ( bufferOffset == rhs.bufferOffset )
+ && ( bufferRowLength == rhs.bufferRowLength )
+ && ( bufferImageHeight == rhs.bufferImageHeight )
+ && ( imageSubresource == rhs.imageSubresource )
+ && ( imageOffset == rhs.imageOffset )
+ && ( imageExtent == rhs.imageExtent );
+ }
+
+ bool operator!=( BufferImageCopy const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DeviceSize bufferOffset;
+ uint32_t bufferRowLength;
+ uint32_t bufferImageHeight;
+ ImageSubresourceLayers imageSubresource;
+ Offset3D imageOffset;
+ Extent3D imageExtent;
+ };
+ static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
+
+ struct ImageResolve
+ {
+ ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
+ Offset3D srcOffset_ = Offset3D(),
+ ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
+ Offset3D dstOffset_ = Offset3D(),
+ Extent3D extent_ = Extent3D() )
+ : srcSubresource( srcSubresource_ )
+ , srcOffset( srcOffset_ )
+ , dstSubresource( dstSubresource_ )
+ , dstOffset( dstOffset_ )
+ , extent( extent_ )
+ {
+ }
+
+ ImageResolve( VkImageResolve const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageResolve ) );
+ }
+
+ ImageResolve& operator=( VkImageResolve const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageResolve ) );
+ return *this;
+ }
+ ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ {
+ srcSubresource = srcSubresource_;
+ return *this;
+ }
+
+ ImageResolve& setSrcOffset( Offset3D srcOffset_ )
+ {
+ srcOffset = srcOffset_;
+ return *this;
+ }
+
+ ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ {
+ dstSubresource = dstSubresource_;
+ return *this;
+ }
+
+ ImageResolve& setDstOffset( Offset3D dstOffset_ )
+ {
+ dstOffset = dstOffset_;
+ return *this;
+ }
+
+ ImageResolve& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ operator VkImageResolve const&() const
+ {
+ return *reinterpret_cast<const VkImageResolve*>(this);
+ }
+
+ operator VkImageResolve &()
+ {
+ return *reinterpret_cast<VkImageResolve*>(this);
+ }
+
+ bool operator==( ImageResolve const& rhs ) const
+ {
+ return ( srcSubresource == rhs.srcSubresource )
+ && ( srcOffset == rhs.srcOffset )
+ && ( dstSubresource == rhs.dstSubresource )
+ && ( dstOffset == rhs.dstOffset )
+ && ( extent == rhs.extent );
+ }
+
+ bool operator!=( ImageResolve const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresourceLayers srcSubresource;
+ Offset3D srcOffset;
+ ImageSubresourceLayers dstSubresource;
+ Offset3D dstOffset;
+ Extent3D extent;
+ };
+ static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
+
+ struct ClearAttachment
+ {
+ ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+ uint32_t colorAttachment_ = 0,
+ ClearValue clearValue_ = ClearValue() )
+ : aspectMask( aspectMask_ )
+ , colorAttachment( colorAttachment_ )
+ , clearValue( clearValue_ )
+ {
+ }
+
+ ClearAttachment( VkClearAttachment const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ClearAttachment ) );
+ }
+
+ ClearAttachment& operator=( VkClearAttachment const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ClearAttachment ) );
+ return *this;
+ }
+ ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
+ {
+ aspectMask = aspectMask_;
+ return *this;
+ }
+
+ ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
+ {
+ colorAttachment = colorAttachment_;
+ return *this;
+ }
+
+ ClearAttachment& setClearValue( ClearValue clearValue_ )
+ {
+ clearValue = clearValue_;
+ return *this;
+ }
+
+ operator VkClearAttachment const&() const
+ {
+ return *reinterpret_cast<const VkClearAttachment*>(this);
+ }
+
+ operator VkClearAttachment &()
+ {
+ return *reinterpret_cast<VkClearAttachment*>(this);
+ }
+
+ ImageAspectFlags aspectMask;
+ uint32_t colorAttachment;
+ ClearValue clearValue;
+ };
+ static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
+
+ struct InputAttachmentAspectReference
+ {
+ InputAttachmentAspectReference( uint32_t subpass_ = 0,
+ uint32_t inputAttachmentIndex_ = 0,
+ ImageAspectFlags aspectMask_ = ImageAspectFlags() )
+ : subpass( subpass_ )
+ , inputAttachmentIndex( inputAttachmentIndex_ )
+ , aspectMask( aspectMask_ )
+ {
+ }
+
+ InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+ }
+
+ InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+ return *this;
+ }
+ InputAttachmentAspectReference& setSubpass( uint32_t subpass_ )
+ {
+ subpass = subpass_;
+ return *this;
+ }
+
+ InputAttachmentAspectReference& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ )
+ {
+ inputAttachmentIndex = inputAttachmentIndex_;
+ return *this;
+ }
+
+ InputAttachmentAspectReference& setAspectMask( ImageAspectFlags aspectMask_ )
+ {
+ aspectMask = aspectMask_;
+ return *this;
+ }
+
+ operator VkInputAttachmentAspectReference const&() const
+ {
+ return *reinterpret_cast<const VkInputAttachmentAspectReference*>(this);
+ }
+
+ operator VkInputAttachmentAspectReference &()
+ {
+ return *reinterpret_cast<VkInputAttachmentAspectReference*>(this);
+ }
+
+ bool operator==( InputAttachmentAspectReference const& rhs ) const
+ {
+ return ( subpass == rhs.subpass )
+ && ( inputAttachmentIndex == rhs.inputAttachmentIndex )
+ && ( aspectMask == rhs.aspectMask );
+ }
+
+ bool operator!=( InputAttachmentAspectReference const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t subpass;
+ uint32_t inputAttachmentIndex;
+ ImageAspectFlags aspectMask;
+ };
+ static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
+
+ using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
+
+ struct RenderPassInputAttachmentAspectCreateInfo
+ {
+ RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
+ const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
+ : aspectReferenceCount( aspectReferenceCount_ )
+ , pAspectReferences( pAspectReferences_ )
+ {
+ }
+
+ RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+ }
+
+ RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+ return *this;
+ }
+ RenderPassInputAttachmentAspectCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ RenderPassInputAttachmentAspectCreateInfo& setAspectReferenceCount( uint32_t aspectReferenceCount_ )
+ {
+ aspectReferenceCount = aspectReferenceCount_;
+ return *this;
+ }
+
+ RenderPassInputAttachmentAspectCreateInfo& setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ )
+ {
+ pAspectReferences = pAspectReferences_;
+ return *this;
+ }
+
+ operator VkRenderPassInputAttachmentAspectCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(this);
+ }
+
+ operator VkRenderPassInputAttachmentAspectCreateInfo &()
+ {
+ return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this);
+ }
+
+ bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( aspectReferenceCount == rhs.aspectReferenceCount )
+ && ( pAspectReferences == rhs.pAspectReferences );
+ }
+
+ bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t aspectReferenceCount;
+ const InputAttachmentAspectReference* pAspectReferences;
+ };
+ static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
+
+ using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
+
+ struct BindImagePlaneMemoryInfo
+ {
+ BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
+ : planeAspect( planeAspect_ )
+ {
+ }
+
+ BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+ }
+
+ BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+ return *this;
+ }
+ BindImagePlaneMemoryInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ BindImagePlaneMemoryInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+ {
+ planeAspect = planeAspect_;
+ return *this;
+ }
+
+ operator VkBindImagePlaneMemoryInfo const&() const
+ {
+ return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(this);
+ }
+
+ operator VkBindImagePlaneMemoryInfo &()
+ {
+ return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this);
+ }
+
+ bool operator==( BindImagePlaneMemoryInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( planeAspect == rhs.planeAspect );
+ }
+
+ bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
+
+ public:
+ const void* pNext = nullptr;
+ ImageAspectFlagBits planeAspect;
+ };
+ static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
+
+ using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
+
+ struct ImagePlaneMemoryRequirementsInfo
+ {
+ ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
+ : planeAspect( planeAspect_ )
+ {
+ }
+
+ ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+ }
+
+ ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+ return *this;
+ }
+ ImagePlaneMemoryRequirementsInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImagePlaneMemoryRequirementsInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+ {
+ planeAspect = planeAspect_;
+ return *this;
+ }
+
+ operator VkImagePlaneMemoryRequirementsInfo const&() const
+ {
+ return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(this);
+ }
+
+ operator VkImagePlaneMemoryRequirementsInfo &()
+ {
+ return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this);
+ }
+
+ bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( planeAspect == rhs.planeAspect );
+ }
+
+ bool operator!=( ImagePlaneMemoryRequirementsInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
+
+ public:
+ const void* pNext = nullptr;
+ ImageAspectFlagBits planeAspect;
+ };
+ static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
+
+ using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
+
+ struct AttachmentReference2KHR
+ {
+ AttachmentReference2KHR( uint32_t attachment_ = 0,
+ ImageLayout layout_ = ImageLayout::eUndefined,
+ ImageAspectFlags aspectMask_ = ImageAspectFlags() )
+ : attachment( attachment_ )
+ , layout( layout_ )
+ , aspectMask( aspectMask_ )
+ {
+ }
+
+ AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+ }
+
+ AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+ return *this;
+ }
+ AttachmentReference2KHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ AttachmentReference2KHR& setAttachment( uint32_t attachment_ )
+ {
+ attachment = attachment_;
+ return *this;
+ }
+
+ AttachmentReference2KHR& setLayout( ImageLayout layout_ )
+ {
+ layout = layout_;
+ return *this;
+ }
+
+ AttachmentReference2KHR& setAspectMask( ImageAspectFlags aspectMask_ )
+ {
+ aspectMask = aspectMask_;
+ return *this;
+ }
+
+ operator VkAttachmentReference2KHR const&() const
+ {
+ return *reinterpret_cast<const VkAttachmentReference2KHR*>(this);
+ }
+
+ operator VkAttachmentReference2KHR &()
+ {
+ return *reinterpret_cast<VkAttachmentReference2KHR*>(this);
+ }
+
+ bool operator==( AttachmentReference2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( attachment == rhs.attachment )
+ && ( layout == rhs.layout )
+ && ( aspectMask == rhs.aspectMask );
+ }
+
+ bool operator!=( AttachmentReference2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eAttachmentReference2KHR;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t attachment;
+ ImageLayout layout;
+ ImageAspectFlags aspectMask;
+ };
+ static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
+
+ enum class SparseImageFormatFlagBits
+ {
+ eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
+ eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
+ eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
+ };
+
+ using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
+
+ VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
+ {
+ return ~( SparseImageFormatFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SparseImageFormatFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
+ };
+ };
+
+ struct SparseImageFormatProperties
+ {
+ operator VkSparseImageFormatProperties const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
+ }
+
+ operator VkSparseImageFormatProperties &()
+ {
+ return *reinterpret_cast<VkSparseImageFormatProperties*>(this);
+ }
+
+ bool operator==( SparseImageFormatProperties const& rhs ) const
+ {
+ return ( aspectMask == rhs.aspectMask )
+ && ( imageGranularity == rhs.imageGranularity )
+ && ( flags == rhs.flags );
+ }
+
+ bool operator!=( SparseImageFormatProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageAspectFlags aspectMask;
+ Extent3D imageGranularity;
+ SparseImageFormatFlags flags;
+ };
+ static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
+
+ struct SparseImageMemoryRequirements
+ {
+ operator VkSparseImageMemoryRequirements const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
+ }
+
+ operator VkSparseImageMemoryRequirements &()
+ {
+ return *reinterpret_cast<VkSparseImageMemoryRequirements*>(this);
+ }
+
+ bool operator==( SparseImageMemoryRequirements const& rhs ) const
+ {
+ return ( formatProperties == rhs.formatProperties )
+ && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
+ && ( imageMipTailSize == rhs.imageMipTailSize )
+ && ( imageMipTailOffset == rhs.imageMipTailOffset )
+ && ( imageMipTailStride == rhs.imageMipTailStride );
+ }
+
+ bool operator!=( SparseImageMemoryRequirements const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ SparseImageFormatProperties formatProperties;
+ uint32_t imageMipTailFirstLod;
+ DeviceSize imageMipTailSize;
+ DeviceSize imageMipTailOffset;
+ DeviceSize imageMipTailStride;
+ };
+ static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
+
+ struct SparseImageFormatProperties2
+ {
+ operator VkSparseImageFormatProperties2 const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageFormatProperties2*>(this);
+ }
+
+ operator VkSparseImageFormatProperties2 &()
+ {
+ return *reinterpret_cast<VkSparseImageFormatProperties2*>(this);
+ }
+
+ bool operator==( SparseImageFormatProperties2 const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( properties == rhs.properties );
+ }
+
+ bool operator!=( SparseImageFormatProperties2 const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eSparseImageFormatProperties2;
+
+ public:
+ void* pNext = nullptr;
+ SparseImageFormatProperties properties;
+ };
+ static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
+
+ using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
+
+ struct SparseImageMemoryRequirements2
+ {
+ operator VkSparseImageMemoryRequirements2 const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>(this);
+ }
+
+ operator VkSparseImageMemoryRequirements2 &()
+ {
+ return *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this);
+ }
+
+ bool operator==( SparseImageMemoryRequirements2 const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memoryRequirements == rhs.memoryRequirements );
+ }
+
+ bool operator!=( SparseImageMemoryRequirements2 const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eSparseImageMemoryRequirements2;
+
+ public:
+ void* pNext = nullptr;
+ SparseImageMemoryRequirements memoryRequirements;
+ };
+ static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
+
+ using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
+
+ enum class SparseMemoryBindFlagBits
+ {
+ eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
+ };
+
+ using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
+
+ VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
+ {
+ return ~( SparseMemoryBindFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SparseMemoryBindFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
+ };
+ };
+
+ struct SparseMemoryBind
+ {
+ SparseMemoryBind( DeviceSize resourceOffset_ = 0,
+ DeviceSize size_ = 0,
+ DeviceMemory memory_ = DeviceMemory(),
+ DeviceSize memoryOffset_ = 0,
+ SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+ : resourceOffset( resourceOffset_ )
+ , size( size_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , flags( flags_ )
+ {
+ }
+
+ SparseMemoryBind( VkSparseMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+ }
+
+ SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+ return *this;
+ }
+ SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
+ {
+ resourceOffset = resourceOffset_;
+ return *this;
+ }
+
+ SparseMemoryBind& setSize( DeviceSize size_ )
+ {
+ size = size_;
+ return *this;
+ }
+
+ SparseMemoryBind& setMemory( DeviceMemory memory_ )
+ {
+ memory = memory_;
+ return *this;
+ }
+
+ SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ {
+ memoryOffset = memoryOffset_;
+ return *this;
+ }
+
+ SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ operator VkSparseMemoryBind const&() const
+ {
+ return *reinterpret_cast<const VkSparseMemoryBind*>(this);
+ }
+
+ operator VkSparseMemoryBind &()
+ {
+ return *reinterpret_cast<VkSparseMemoryBind*>(this);
+ }
+
+ bool operator==( SparseMemoryBind const& rhs ) const
+ {
+ return ( resourceOffset == rhs.resourceOffset )
+ && ( size == rhs.size )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( flags == rhs.flags );
+ }
+
+ bool operator!=( SparseMemoryBind const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DeviceSize resourceOffset;
+ DeviceSize size;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ SparseMemoryBindFlags flags;
+ };
+ static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
+
+ struct SparseImageMemoryBind
+ {
+ SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(),
+ Offset3D offset_ = Offset3D(),
+ Extent3D extent_ = Extent3D(),
+ DeviceMemory memory_ = DeviceMemory(),
+ DeviceSize memoryOffset_ = 0,
+ SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+ : subresource( subresource_ )
+ , offset( offset_ )
+ , extent( extent_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , flags( flags_ )
+ {
+ }
+
+ SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+ }
+
+ SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+ return *this;
+ }
+ SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
+ {
+ subresource = subresource_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setOffset( Offset3D offset_ )
+ {
+ offset = offset_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
+ {
+ memory = memory_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
+ {
+ memoryOffset = memoryOffset_;
+ return *this;
+ }
+
+ SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ operator VkSparseImageMemoryBind const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
+ }
+
+ operator VkSparseImageMemoryBind &()
+ {
+ return *reinterpret_cast<VkSparseImageMemoryBind*>(this);
+ }
+
+ bool operator==( SparseImageMemoryBind const& rhs ) const
+ {
+ return ( subresource == rhs.subresource )
+ && ( offset == rhs.offset )
+ && ( extent == rhs.extent )
+ && ( memory == rhs.memory )
+ && ( memoryOffset == rhs.memoryOffset )
+ && ( flags == rhs.flags );
+ }
+
+ bool operator!=( SparseImageMemoryBind const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ImageSubresource subresource;
+ Offset3D offset;
+ Extent3D extent;
+ DeviceMemory memory;
+ DeviceSize memoryOffset;
+ SparseMemoryBindFlags flags;
+ };
+ static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
+
+ struct SparseBufferMemoryBindInfo
+ {
+ SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(),
+ uint32_t bindCount_ = 0,
+ const SparseMemoryBind* pBinds_ = nullptr )
+ : buffer( buffer_ )
+ , bindCount( bindCount_ )
+ , pBinds( pBinds_ )
+ {
+ }
+
+ SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+ }
+
+ SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+ return *this;
+ }
+ SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
+ {
+ buffer = buffer_;
+ return *this;
+ }
+
+ SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ {
+ bindCount = bindCount_;
+ return *this;
+ }
+
+ SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ {
+ pBinds = pBinds_;
+ return *this;
+ }
+
+ operator VkSparseBufferMemoryBindInfo const&() const
+ {
+ return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
+ }
+
+ operator VkSparseBufferMemoryBindInfo &()
+ {
+ return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this);
+ }
+
+ bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
+ {
+ return ( buffer == rhs.buffer )
+ && ( bindCount == rhs.bindCount )
+ && ( pBinds == rhs.pBinds );
+ }
+
+ bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Buffer buffer;
+ uint32_t bindCount;
+ const SparseMemoryBind* pBinds;
+ };
+ static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
+
+ struct SparseImageOpaqueMemoryBindInfo
+ {
+ SparseImageOpaqueMemoryBindInfo( Image image_ = Image(),
+ uint32_t bindCount_ = 0,
+ const SparseMemoryBind* pBinds_ = nullptr )
+ : image( image_ )
+ , bindCount( bindCount_ )
+ , pBinds( pBinds_ )
+ {
+ }
+
+ SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+ }
+
+ SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+ return *this;
+ }
+ SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ {
+ bindCount = bindCount_;
+ return *this;
+ }
+
+ SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
+ {
+ pBinds = pBinds_;
+ return *this;
+ }
+
+ operator VkSparseImageOpaqueMemoryBindInfo const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
+ }
+
+ operator VkSparseImageOpaqueMemoryBindInfo &()
+ {
+ return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this);
+ }
+
+ bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ {
+ return ( image == rhs.image )
+ && ( bindCount == rhs.bindCount )
+ && ( pBinds == rhs.pBinds );
+ }
+
+ bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Image image;
+ uint32_t bindCount;
+ const SparseMemoryBind* pBinds;
+ };
+ static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
+
+ struct SparseImageMemoryBindInfo
+ {
+ SparseImageMemoryBindInfo( Image image_ = Image(),
+ uint32_t bindCount_ = 0,
+ const SparseImageMemoryBind* pBinds_ = nullptr )
+ : image( image_ )
+ , bindCount( bindCount_ )
+ , pBinds( pBinds_ )
+ {
+ }
+
+ SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+ }
+
+ SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+ return *this;
+ }
+ SparseImageMemoryBindInfo& setImage( Image image_ )
+ {
+ image = image_;
+ return *this;
+ }
+
+ SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
+ {
+ bindCount = bindCount_;
+ return *this;
+ }
+
+ SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
+ {
+ pBinds = pBinds_;
+ return *this;
+ }
+
+ operator VkSparseImageMemoryBindInfo const&() const
+ {
+ return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
+ }
+
+ operator VkSparseImageMemoryBindInfo &()
+ {
+ return *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this);
+ }
+
+ bool operator==( SparseImageMemoryBindInfo const& rhs ) const
+ {
+ return ( image == rhs.image )
+ && ( bindCount == rhs.bindCount )
+ && ( pBinds == rhs.pBinds );
+ }
+
+ bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Image image;
+ uint32_t bindCount;
+ const SparseImageMemoryBind* pBinds;
+ };
+ static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
+
+ struct BindSparseInfo
+ {
+ BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
+ const Semaphore* pWaitSemaphores_ = nullptr,
+ uint32_t bufferBindCount_ = 0,
+ const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
+ uint32_t imageOpaqueBindCount_ = 0,
+ const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
+ uint32_t imageBindCount_ = 0,
+ const SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const Semaphore* pSignalSemaphores_ = nullptr )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , bufferBindCount( bufferBindCount_ )
+ , pBufferBinds( pBufferBinds_ )
+ , imageOpaqueBindCount( imageOpaqueBindCount_ )
+ , pImageOpaqueBinds( pImageOpaqueBinds_ )
+ , imageBindCount( imageBindCount_ )
+ , pImageBinds( pImageBinds_ )
+ , signalSemaphoreCount( signalSemaphoreCount_ )
+ , pSignalSemaphores( pSignalSemaphores_ )
+ {
+ }
+
+ BindSparseInfo( VkBindSparseInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( BindSparseInfo ) );
+ }
+
+ BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( BindSparseInfo ) );
+ return *this;
+ }
+ BindSparseInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+ {
+ waitSemaphoreCount = waitSemaphoreCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ {
+ pWaitSemaphores = pWaitSemaphores_;
+ return *this;
+ }
+
+ BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
+ {
+ bufferBindCount = bufferBindCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+ {
+ pBufferBinds = pBufferBinds_;
+ return *this;
+ }
+
+ BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
+ {
+ imageOpaqueBindCount = imageOpaqueBindCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+ {
+ pImageOpaqueBinds = pImageOpaqueBinds_;
+ return *this;
+ }
+
+ BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
+ {
+ imageBindCount = imageBindCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+ {
+ pImageBinds = pImageBinds_;
+ return *this;
+ }
+
+ BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+ {
+ signalSemaphoreCount = signalSemaphoreCount_;
+ return *this;
+ }
+
+ BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+ {
+ pSignalSemaphores = pSignalSemaphores_;
+ return *this;
+ }
+
+ operator VkBindSparseInfo const&() const
+ {
+ return *reinterpret_cast<const VkBindSparseInfo*>(this);
+ }
+
+ operator VkBindSparseInfo &()
+ {
+ return *reinterpret_cast<VkBindSparseInfo*>(this);
+ }
+
+ bool operator==( BindSparseInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+ && ( pWaitSemaphores == rhs.pWaitSemaphores )
+ && ( bufferBindCount == rhs.bufferBindCount )
+ && ( pBufferBinds == rhs.pBufferBinds )
+ && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
+ && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
+ && ( imageBindCount == rhs.imageBindCount )
+ && ( pImageBinds == rhs.pImageBinds )
+ && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
+ && ( pSignalSemaphores == rhs.pSignalSemaphores );
+ }
+
+ bool operator!=( BindSparseInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eBindSparseInfo;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreCount;
+ const Semaphore* pWaitSemaphores;
+ uint32_t bufferBindCount;
+ const SparseBufferMemoryBindInfo* pBufferBinds;
+ uint32_t imageOpaqueBindCount;
+ const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+ uint32_t imageBindCount;
+ const SparseImageMemoryBindInfo* pImageBinds;
+ uint32_t signalSemaphoreCount;
+ const Semaphore* pSignalSemaphores;
+ };
+ static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
+
+ enum class PipelineStageFlagBits
+ {
+ eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
+ eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+ eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+ eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
+ eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
+ eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+ eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+ eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+ eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+ eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+ eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+ eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
+ eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+ eHost = VK_PIPELINE_STAGE_HOST_BIT,
+ eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+ eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
+ eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
+ eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,
+ eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
+ eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV,
+ eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
+ eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
+ eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
+ };
+
+ using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
+
+ VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
+ {
+ return ~( PipelineStageFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<PipelineStageFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV)
+ };
+ };
+
+ struct QueueFamilyCheckpointPropertiesNV
+ {
+ operator VkQueueFamilyCheckpointPropertiesNV const&() const
+ {
+ return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(this);
+ }
+
+ operator VkQueueFamilyCheckpointPropertiesNV &()
+ {
+ return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this);
+ }
+
+ bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+ }
+
+ bool operator!=( QueueFamilyCheckpointPropertiesNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+
+ public:
+ void* pNext = nullptr;
+ PipelineStageFlags checkpointExecutionStageMask;
+ };
+ static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
+
+ struct CheckpointDataNV
+ {
+ operator VkCheckpointDataNV const&() const
+ {
+ return *reinterpret_cast<const VkCheckpointDataNV*>(this);
+ }
+
+ operator VkCheckpointDataNV &()
+ {
+ return *reinterpret_cast<VkCheckpointDataNV*>(this);
+ }
+
+ bool operator==( CheckpointDataNV const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( stage == rhs.stage )
+ && ( pCheckpointMarker == rhs.pCheckpointMarker );
+ }
+
+ bool operator!=( CheckpointDataNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eCheckpointDataNV;
+
+ public:
+ void* pNext = nullptr;
+ PipelineStageFlagBits stage;
+ void* pCheckpointMarker;
+ };
+ static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
+
+ enum class CommandPoolCreateFlagBits
+ {
+ eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
+ eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+ eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT
+ };
+
+ using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
+
+ VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
+ {
+ return ~( CommandPoolCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandPoolCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) | VkFlags(CommandPoolCreateFlagBits::eProtected)
+ };
+ };
+
+ struct CommandPoolCreateInfo
+ {
+ CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0 )
+ : flags( flags_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ {
+ }
+
+ CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+ }
+
+ CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+ return *this;
+ }
+ CommandPoolCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+ {
+ queueFamilyIndex = queueFamilyIndex_;
+ return *this;
+ }
+
+ operator VkCommandPoolCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
+ }
+
+ operator VkCommandPoolCreateInfo &()
+ {
+ return *reinterpret_cast<VkCommandPoolCreateInfo*>(this);
+ }
+
+ bool operator==( CommandPoolCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( queueFamilyIndex == rhs.queueFamilyIndex );
+ }
+
+ bool operator!=( CommandPoolCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eCommandPoolCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ CommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ };
+ static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
+
+ enum class CommandPoolResetFlagBits
+ {
+ eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
+ };
+
+ using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
+
+ VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
+ {
+ return ~( CommandPoolResetFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandPoolResetFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
+ };
+ };
+
+ enum class CommandBufferResetFlagBits
+ {
+ eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+ };
+
+ using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
+
+ VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+ {
+ return ~( CommandBufferResetFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<CommandBufferResetFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
+ };
+ };
+
+ enum class SampleCountFlagBits
+ {
+ e1 = VK_SAMPLE_COUNT_1_BIT,
+ e2 = VK_SAMPLE_COUNT_2_BIT,
+ e4 = VK_SAMPLE_COUNT_4_BIT,
+ e8 = VK_SAMPLE_COUNT_8_BIT,
+ e16 = VK_SAMPLE_COUNT_16_BIT,
+ e32 = VK_SAMPLE_COUNT_32_BIT,
+ e64 = VK_SAMPLE_COUNT_64_BIT
+ };
+
+ using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
+
+ VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
+ {
+ return ~( SampleCountFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<SampleCountFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
+ };
+ };
+
+ struct ImageFormatProperties
+ {
+ operator VkImageFormatProperties const&() const
+ {
+ return *reinterpret_cast<const VkImageFormatProperties*>(this);
+ }
+
+ operator VkImageFormatProperties &()
+ {
+ return *reinterpret_cast<VkImageFormatProperties*>(this);
+ }
+
+ bool operator==( ImageFormatProperties const& rhs ) const
+ {
+ return ( maxExtent == rhs.maxExtent )
+ && ( maxMipLevels == rhs.maxMipLevels )
+ && ( maxArrayLayers == rhs.maxArrayLayers )
+ && ( sampleCounts == rhs.sampleCounts )
+ && ( maxResourceSize == rhs.maxResourceSize );
+ }
+
+ bool operator!=( ImageFormatProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Extent3D maxExtent;
+ uint32_t maxMipLevels;
+ uint32_t maxArrayLayers;
+ SampleCountFlags sampleCounts;
+ DeviceSize maxResourceSize;
+ };
+ static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
+
+ struct ImageCreateInfo
+ {
+ ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(),
+ ImageType imageType_ = ImageType::e1D,
+ Format format_ = Format::eUndefined,
+ Extent3D extent_ = Extent3D(),
+ uint32_t mipLevels_ = 0,
+ uint32_t arrayLayers_ = 0,
+ SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+ ImageTiling tiling_ = ImageTiling::eOptimal,
+ ImageUsageFlags usage_ = ImageUsageFlags(),
+ SharingMode sharingMode_ = SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr,
+ ImageLayout initialLayout_ = ImageLayout::eUndefined )
+ : flags( flags_ )
+ , imageType( imageType_ )
+ , format( format_ )
+ , extent( extent_ )
+ , mipLevels( mipLevels_ )
+ , arrayLayers( arrayLayers_ )
+ , samples( samples_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , initialLayout( initialLayout_ )
+ {
+ }
+
+ ImageCreateInfo( VkImageCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+ }
+
+ ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+ return *this;
+ }
+ ImageCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ImageCreateInfo& setImageType( ImageType imageType_ )
+ {
+ imageType = imageType_;
+ return *this;
+ }
+
+ ImageCreateInfo& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ ImageCreateInfo& setExtent( Extent3D extent_ )
+ {
+ extent = extent_;
+ return *this;
+ }
+
+ ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
+ {
+ mipLevels = mipLevels_;
+ return *this;
+ }
+
+ ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
+ {
+ arrayLayers = arrayLayers_;
+ return *this;
+ }
+
+ ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ ImageCreateInfo& setTiling( ImageTiling tiling_ )
+ {
+ tiling = tiling_;
+ return *this;
+ }
+
+ ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
+ {
+ sharingMode = sharingMode_;
+ return *this;
+ }
+
+ ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ {
+ queueFamilyIndexCount = queueFamilyIndexCount_;
+ return *this;
+ }
+
+ ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ {
+ pQueueFamilyIndices = pQueueFamilyIndices_;
+ return *this;
+ }
+
+ ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
+ {
+ initialLayout = initialLayout_;
+ return *this;
+ }
+
+ operator VkImageCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkImageCreateInfo*>(this);
+ }
+
+ operator VkImageCreateInfo &()
+ {
+ return *reinterpret_cast<VkImageCreateInfo*>(this);
+ }
+
+ bool operator==( ImageCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( imageType == rhs.imageType )
+ && ( format == rhs.format )
+ && ( extent == rhs.extent )
+ && ( mipLevels == rhs.mipLevels )
+ && ( arrayLayers == rhs.arrayLayers )
+ && ( samples == rhs.samples )
+ && ( tiling == rhs.tiling )
+ && ( usage == rhs.usage )
+ && ( sharingMode == rhs.sharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
+ && ( initialLayout == rhs.initialLayout );
+ }
+
+ bool operator!=( ImageCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eImageCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ ImageCreateFlags flags;
+ ImageType imageType;
+ Format format;
+ Extent3D extent;
+ uint32_t mipLevels;
+ uint32_t arrayLayers;
+ SampleCountFlagBits samples;
+ ImageTiling tiling;
+ ImageUsageFlags usage;
+ SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ ImageLayout initialLayout;
+ };
+ static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
+
+ struct PipelineMultisampleStateCreateInfo
+ {
+ PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(),
+ SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1,
+ Bool32 sampleShadingEnable_ = 0,
+ float minSampleShading_ = 0,
+ const SampleMask* pSampleMask_ = nullptr,
+ Bool32 alphaToCoverageEnable_ = 0,
+ Bool32 alphaToOneEnable_ = 0 )
+ : flags( flags_ )
+ , rasterizationSamples( rasterizationSamples_ )
+ , sampleShadingEnable( sampleShadingEnable_ )
+ , minSampleShading( minSampleShading_ )
+ , pSampleMask( pSampleMask_ )
+ , alphaToCoverageEnable( alphaToCoverageEnable_ )
+ , alphaToOneEnable( alphaToOneEnable_ )
+ {
+ }
+
+ PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+ }
+
+ PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+ return *this;
+ }
+ PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
+ {
+ rasterizationSamples = rasterizationSamples_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
+ {
+ sampleShadingEnable = sampleShadingEnable_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
+ {
+ minSampleShading = minSampleShading_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
+ {
+ pSampleMask = pSampleMask_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+ {
+ alphaToCoverageEnable = alphaToCoverageEnable_;
+ return *this;
+ }
+
+ PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+ {
+ alphaToOneEnable = alphaToOneEnable_;
+ return *this;
+ }
+
+ operator VkPipelineMultisampleStateCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
+ }
+
+ operator VkPipelineMultisampleStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this);
+ }
+
+ bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( rasterizationSamples == rhs.rasterizationSamples )
+ && ( sampleShadingEnable == rhs.sampleShadingEnable )
+ && ( minSampleShading == rhs.minSampleShading )
+ && ( pSampleMask == rhs.pSampleMask )
+ && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
+ && ( alphaToOneEnable == rhs.alphaToOneEnable );
+ }
+
+ bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ PipelineMultisampleStateCreateFlags flags;
+ SampleCountFlagBits rasterizationSamples;
+ Bool32 sampleShadingEnable;
+ float minSampleShading;
+ const SampleMask* pSampleMask;
+ Bool32 alphaToCoverageEnable;
+ Bool32 alphaToOneEnable;
+ };
+ static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
+
+ struct GraphicsPipelineCreateInfo
+ {
+ GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+ uint32_t stageCount_ = 0,
+ const PipelineShaderStageCreateInfo* pStages_ = nullptr,
+ const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
+ const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
+ const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
+ const PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
+ const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
+ const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
+ const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
+ const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
+ const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
+ PipelineLayout layout_ = PipelineLayout(),
+ RenderPass renderPass_ = RenderPass(),
+ uint32_t subpass_ = 0,
+ Pipeline basePipelineHandle_ = Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : flags( flags_ )
+ , stageCount( stageCount_ )
+ , pStages( pStages_ )
+ , pVertexInputState( pVertexInputState_ )
+ , pInputAssemblyState( pInputAssemblyState_ )
+ , pTessellationState( pTessellationState_ )
+ , pViewportState( pViewportState_ )
+ , pRasterizationState( pRasterizationState_ )
+ , pMultisampleState( pMultisampleState_ )
+ , pDepthStencilState( pDepthStencilState_ )
+ , pColorBlendState( pColorBlendState_ )
+ , pDynamicState( pDynamicState_ )
+ , layout( layout_ )
+ , renderPass( renderPass_ )
+ , subpass( subpass_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
+ {
+ }
+
+ GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
+ }
+
+ GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
+ return *this;
+ }
+ GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
+ {
+ stageCount = stageCount_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+ {
+ pStages = pStages_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
+ {
+ pVertexInputState = pVertexInputState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+ {
+ pInputAssemblyState = pInputAssemblyState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+ {
+ pTessellationState = pTessellationState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+ {
+ pViewportState = pViewportState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+ {
+ pRasterizationState = pRasterizationState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+ {
+ pMultisampleState = pMultisampleState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+ {
+ pDepthStencilState = pDepthStencilState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+ {
+ pColorBlendState = pColorBlendState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+ {
+ pDynamicState = pDynamicState_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
+ {
+ layout = layout_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
+ {
+ renderPass = renderPass_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
+ {
+ subpass = subpass_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ {
+ basePipelineHandle = basePipelineHandle_;
+ return *this;
+ }
+
+ GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
+ {
+ basePipelineIndex = basePipelineIndex_;
+ return *this;
+ }
+
+ operator VkGraphicsPipelineCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
+ }
+
+ operator VkGraphicsPipelineCreateInfo &()
+ {
+ return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this);
+ }
+
+ bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( stageCount == rhs.stageCount )
+ && ( pStages == rhs.pStages )
+ && ( pVertexInputState == rhs.pVertexInputState )
+ && ( pInputAssemblyState == rhs.pInputAssemblyState )
+ && ( pTessellationState == rhs.pTessellationState )
+ && ( pViewportState == rhs.pViewportState )
+ && ( pRasterizationState == rhs.pRasterizationState )
+ && ( pMultisampleState == rhs.pMultisampleState )
+ && ( pDepthStencilState == rhs.pDepthStencilState )
+ && ( pColorBlendState == rhs.pColorBlendState )
+ && ( pDynamicState == rhs.pDynamicState )
+ && ( layout == rhs.layout )
+ && ( renderPass == rhs.renderPass )
+ && ( subpass == rhs.subpass )
+ && ( basePipelineHandle == rhs.basePipelineHandle )
+ && ( basePipelineIndex == rhs.basePipelineIndex );
+ }
+
+ bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ PipelineCreateFlags flags;
+ uint32_t stageCount;
+ const PipelineShaderStageCreateInfo* pStages;
+ const PipelineVertexInputStateCreateInfo* pVertexInputState;
+ const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ const PipelineTessellationStateCreateInfo* pTessellationState;
+ const PipelineViewportStateCreateInfo* pViewportState;
+ const PipelineRasterizationStateCreateInfo* pRasterizationState;
+ const PipelineMultisampleStateCreateInfo* pMultisampleState;
+ const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ const PipelineColorBlendStateCreateInfo* pColorBlendState;
+ const PipelineDynamicStateCreateInfo* pDynamicState;
+ PipelineLayout layout;
+ RenderPass renderPass;
+ uint32_t subpass;
+ Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ };
+ static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceLimits
+ {
+ operator VkPhysicalDeviceLimits const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
+ }
+
+ operator VkPhysicalDeviceLimits &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceLimits*>(this);
+ }
+
+ bool operator==( PhysicalDeviceLimits const& rhs ) const
+ {
+ return ( maxImageDimension1D == rhs.maxImageDimension1D )
+ && ( maxImageDimension2D == rhs.maxImageDimension2D )
+ && ( maxImageDimension3D == rhs.maxImageDimension3D )
+ && ( maxImageDimensionCube == rhs.maxImageDimensionCube )
+ && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+ && ( maxTexelBufferElements == rhs.maxTexelBufferElements )
+ && ( maxUniformBufferRange == rhs.maxUniformBufferRange )
+ && ( maxStorageBufferRange == rhs.maxStorageBufferRange )
+ && ( maxPushConstantsSize == rhs.maxPushConstantsSize )
+ && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount )
+ && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount )
+ && ( bufferImageGranularity == rhs.bufferImageGranularity )
+ && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize )
+ && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets )
+ && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers )
+ && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers )
+ && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers )
+ && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages )
+ && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages )
+ && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments )
+ && ( maxPerStageResources == rhs.maxPerStageResources )
+ && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers )
+ && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers )
+ && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic )
+ && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers )
+ && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic )
+ && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages )
+ && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages )
+ && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments )
+ && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes )
+ && ( maxVertexInputBindings == rhs.maxVertexInputBindings )
+ && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset )
+ && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride )
+ && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents )
+ && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel )
+ && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize )
+ && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents )
+ && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents )
+ && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents )
+ && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents )
+ && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents )
+ && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents )
+ && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations )
+ && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents )
+ && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents )
+ && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices )
+ && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents )
+ && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents )
+ && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments )
+ && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
+ && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
+ && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
+ && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
+ && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+ && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
+ && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
+ && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
+ && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue )
+ && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount )
+ && ( maxSamplerLodBias == rhs.maxSamplerLodBias )
+ && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy )
+ && ( maxViewports == rhs.maxViewports )
+ && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
+ && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
+ && ( viewportSubPixelBits == rhs.viewportSubPixelBits )
+ && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
+ && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
+ && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment )
+ && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment )
+ && ( minTexelOffset == rhs.minTexelOffset )
+ && ( maxTexelOffset == rhs.maxTexelOffset )
+ && ( minTexelGatherOffset == rhs.minTexelGatherOffset )
+ && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset )
+ && ( minInterpolationOffset == rhs.minInterpolationOffset )
+ && ( maxInterpolationOffset == rhs.maxInterpolationOffset )
+ && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits )
+ && ( maxFramebufferWidth == rhs.maxFramebufferWidth )
+ && ( maxFramebufferHeight == rhs.maxFramebufferHeight )
+ && ( maxFramebufferLayers == rhs.maxFramebufferLayers )
+ && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts )
+ && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts )
+ && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts )
+ && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts )
+ && ( maxColorAttachments == rhs.maxColorAttachments )
+ && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts )
+ && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts )
+ && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts )
+ && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts )
+ && ( storageImageSampleCounts == rhs.storageImageSampleCounts )
+ && ( maxSampleMaskWords == rhs.maxSampleMaskWords )
+ && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics )
+ && ( timestampPeriod == rhs.timestampPeriod )
+ && ( maxClipDistances == rhs.maxClipDistances )
+ && ( maxCullDistances == rhs.maxCullDistances )
+ && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances )
+ && ( discreteQueuePriorities == rhs.discreteQueuePriorities )
+ && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
+ && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
+ && ( pointSizeGranularity == rhs.pointSizeGranularity )
+ && ( lineWidthGranularity == rhs.lineWidthGranularity )
+ && ( strictLines == rhs.strictLines )
+ && ( standardSampleLocations == rhs.standardSampleLocations )
+ && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment )
+ && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment )
+ && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+ }
+
+ bool operator!=( PhysicalDeviceLimits const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t maxImageDimension1D;
+ uint32_t maxImageDimension2D;
+ uint32_t maxImageDimension3D;
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+ uint32_t maxTexelBufferElements;
+ uint32_t maxUniformBufferRange;
+ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
+ uint32_t maxSamplerAllocationCount;
+ DeviceSize bufferImageGranularity;
+ DeviceSize sparseAddressSpaceSize;
+ uint32_t maxBoundDescriptorSets;
+ uint32_t maxPerStageDescriptorSamplers;
+ uint32_t maxPerStageDescriptorUniformBuffers;
+ uint32_t maxPerStageDescriptorStorageBuffers;
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
+ uint32_t maxPerStageDescriptorInputAttachments;
+ uint32_t maxPerStageResources;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetUniformBuffersDynamic;
+ uint32_t maxDescriptorSetStorageBuffers;
+ uint32_t maxDescriptorSetStorageBuffersDynamic;
+ uint32_t maxDescriptorSetSampledImages;
+ uint32_t maxDescriptorSetStorageImages;
+ uint32_t maxDescriptorSetInputAttachments;
+ uint32_t maxVertexInputAttributes;
+ uint32_t maxVertexInputBindings;
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+ uint32_t maxTessellationGenerationLevel;
+ uint32_t maxTessellationPatchSize;
+ uint32_t maxTessellationControlPerVertexInputComponents;
+ uint32_t maxTessellationControlPerVertexOutputComponents;
+ uint32_t maxTessellationControlPerPatchOutputComponents;
+ uint32_t maxTessellationControlTotalOutputComponents;
+ uint32_t maxTessellationEvaluationInputComponents;
+ uint32_t maxTessellationEvaluationOutputComponents;
+ uint32_t maxGeometryShaderInvocations;
+ uint32_t maxGeometryInputComponents;
+ uint32_t maxGeometryOutputComponents;
+ uint32_t maxGeometryOutputVertices;
+ uint32_t maxGeometryTotalOutputComponents;
+ uint32_t maxFragmentInputComponents;
+ uint32_t maxFragmentOutputAttachments;
+ uint32_t maxFragmentDualSrcAttachments;
+ uint32_t maxFragmentCombinedOutputResources;
+ uint32_t maxComputeSharedMemorySize;
+ uint32_t maxComputeWorkGroupCount[3];
+ uint32_t maxComputeWorkGroupInvocations;
+ uint32_t maxComputeWorkGroupSize[3];
+ uint32_t subPixelPrecisionBits;
+ uint32_t subTexelPrecisionBits;
+ uint32_t mipmapPrecisionBits;
+ uint32_t maxDrawIndexedIndexValue;
+ uint32_t maxDrawIndirectCount;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ uint32_t maxViewports;
+ uint32_t maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ uint32_t viewportSubPixelBits;
+ size_t minMemoryMapAlignment;
+ DeviceSize minTexelBufferOffsetAlignment;
+ DeviceSize minUniformBufferOffsetAlignment;
+ DeviceSize minStorageBufferOffsetAlignment;
+ int32_t minTexelOffset;
+ uint32_t maxTexelOffset;
+ int32_t minTexelGatherOffset;
+ uint32_t maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+ uint32_t subPixelInterpolationOffsetBits;
+ uint32_t maxFramebufferWidth;
+ uint32_t maxFramebufferHeight;
+ uint32_t maxFramebufferLayers;
+ SampleCountFlags framebufferColorSampleCounts;
+ SampleCountFlags framebufferDepthSampleCounts;
+ SampleCountFlags framebufferStencilSampleCounts;
+ SampleCountFlags framebufferNoAttachmentsSampleCounts;
+ uint32_t maxColorAttachments;
+ SampleCountFlags sampledImageColorSampleCounts;
+ SampleCountFlags sampledImageIntegerSampleCounts;
+ SampleCountFlags sampledImageDepthSampleCounts;
+ SampleCountFlags sampledImageStencilSampleCounts;
+ SampleCountFlags storageImageSampleCounts;
+ uint32_t maxSampleMaskWords;
+ Bool32 timestampComputeAndGraphics;
+ float timestampPeriod;
+ uint32_t maxClipDistances;
+ uint32_t maxCullDistances;
+ uint32_t maxCombinedClipAndCullDistances;
+ uint32_t discreteQueuePriorities;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+ Bool32 strictLines;
+ Bool32 standardSampleLocations;
+ DeviceSize optimalBufferCopyOffsetAlignment;
+ DeviceSize optimalBufferCopyRowPitchAlignment;
+ DeviceSize nonCoherentAtomSize;
+ };
+ static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceProperties
+ {
+ operator VkPhysicalDeviceProperties const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
+ }
+
+ operator VkPhysicalDeviceProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceProperties*>(this);
+ }
+
+ bool operator==( PhysicalDeviceProperties const& rhs ) const
+ {
+ return ( apiVersion == rhs.apiVersion )
+ && ( driverVersion == rhs.driverVersion )
+ && ( vendorID == rhs.vendorID )
+ && ( deviceID == rhs.deviceID )
+ && ( deviceType == rhs.deviceType )
+ && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
+ && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
+ && ( limits == rhs.limits )
+ && ( sparseProperties == rhs.sparseProperties );
+ }
+
+ bool operator!=( PhysicalDeviceProperties const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t apiVersion;
+ uint32_t driverVersion;
+ uint32_t vendorID;
+ uint32_t deviceID;
+ PhysicalDeviceType deviceType;
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+ uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+ PhysicalDeviceLimits limits;
+ PhysicalDeviceSparseProperties sparseProperties;
+ };
+ static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceProperties2
+ {
+ operator VkPhysicalDeviceProperties2 const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceProperties2*>(this);
+ }
+
+ operator VkPhysicalDeviceProperties2 &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceProperties2*>(this);
+ }
+
+ bool operator==( PhysicalDeviceProperties2 const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( properties == rhs.properties );
+ }
+
+ bool operator!=( PhysicalDeviceProperties2 const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceProperties2;
+
+ public:
+ void* pNext = nullptr;
+ PhysicalDeviceProperties properties;
+ };
+ static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
+
+ using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
+
+ struct ImageFormatProperties2
+ {
+ operator VkImageFormatProperties2 const&() const
+ {
+ return *reinterpret_cast<const VkImageFormatProperties2*>(this);
+ }
+
+ operator VkImageFormatProperties2 &()
+ {
+ return *reinterpret_cast<VkImageFormatProperties2*>(this);
+ }
+
+ bool operator==( ImageFormatProperties2 const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( imageFormatProperties == rhs.imageFormatProperties );
+ }
+
+ bool operator!=( ImageFormatProperties2 const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eImageFormatProperties2;
+
+ public:
+ void* pNext = nullptr;
+ ImageFormatProperties imageFormatProperties;
+ };
+ static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
+
+ using ImageFormatProperties2KHR = ImageFormatProperties2;
+
+ struct PhysicalDeviceSparseImageFormatInfo2
+ {
+ PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined,
+ ImageType type_ = ImageType::e1D,
+ SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+ ImageUsageFlags usage_ = ImageUsageFlags(),
+ ImageTiling tiling_ = ImageTiling::eOptimal )
+ : format( format_ )
+ , type( type_ )
+ , samples( samples_ )
+ , usage( usage_ )
+ , tiling( tiling_ )
+ {
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
+ return *this;
+ }
+ PhysicalDeviceSparseImageFormatInfo2& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& setType( ImageType type_ )
+ {
+ type = type_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& setUsage( ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& setTiling( ImageTiling tiling_ )
+ {
+ tiling = tiling_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceSparseImageFormatInfo2 const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(this);
+ }
+
+ operator VkPhysicalDeviceSparseImageFormatInfo2 &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this);
+ }
+
+ bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( format == rhs.format )
+ && ( type == rhs.type )
+ && ( samples == rhs.samples )
+ && ( usage == rhs.usage )
+ && ( tiling == rhs.tiling );
+ }
+
+ bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+
+ public:
+ const void* pNext = nullptr;
+ Format format;
+ ImageType type;
+ SampleCountFlagBits samples;
+ ImageUsageFlags usage;
+ ImageTiling tiling;
+ };
+ static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
+
+ using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
+
+ struct SampleLocationsInfoEXT
+ {
+ SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
+ Extent2D sampleLocationGridSize_ = Extent2D(),
+ uint32_t sampleLocationsCount_ = 0,
+ const SampleLocationEXT* pSampleLocations_ = nullptr )
+ : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+ , sampleLocationGridSize( sampleLocationGridSize_ )
+ , sampleLocationsCount( sampleLocationsCount_ )
+ , pSampleLocations( pSampleLocations_ )
+ {
+ }
+
+ SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+ }
+
+ SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+ return *this;
+ }
+ SampleLocationsInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
+ {
+ sampleLocationsPerPixel = sampleLocationsPerPixel_;
+ return *this;
+ }
+
+ SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
+ {
+ sampleLocationGridSize = sampleLocationGridSize_;
+ return *this;
+ }
+
+ SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ )
+ {
+ sampleLocationsCount = sampleLocationsCount_;
+ return *this;
+ }
+
+ SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
+ {
+ pSampleLocations = pSampleLocations_;
+ return *this;
+ }
+
+ operator VkSampleLocationsInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this);
+ }
+
+ operator VkSampleLocationsInfoEXT &()
+ {
+ return *reinterpret_cast<VkSampleLocationsInfoEXT*>(this);
+ }
+
+ bool operator==( SampleLocationsInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel )
+ && ( sampleLocationGridSize == rhs.sampleLocationGridSize )
+ && ( sampleLocationsCount == rhs.sampleLocationsCount )
+ && ( pSampleLocations == rhs.pSampleLocations );
+ }
+
+ bool operator!=( SampleLocationsInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eSampleLocationsInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ SampleCountFlagBits sampleLocationsPerPixel;
+ Extent2D sampleLocationGridSize;
+ uint32_t sampleLocationsCount;
+ const SampleLocationEXT* pSampleLocations;
+ };
+ static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
+
+ struct AttachmentSampleLocationsEXT
+ {
+ AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
+ SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+ : attachmentIndex( attachmentIndex_ )
+ , sampleLocationsInfo( sampleLocationsInfo_ )
+ {
+ }
+
+ AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+ }
+
+ AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+ return *this;
+ }
+ AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ )
+ {
+ attachmentIndex = attachmentIndex_;
+ return *this;
+ }
+
+ AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ {
+ sampleLocationsInfo = sampleLocationsInfo_;
+ return *this;
+ }
+
+ operator VkAttachmentSampleLocationsEXT const&() const
+ {
+ return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this);
+ }
+
+ operator VkAttachmentSampleLocationsEXT &()
+ {
+ return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this);
+ }
+
+ bool operator==( AttachmentSampleLocationsEXT const& rhs ) const
+ {
+ return ( attachmentIndex == rhs.attachmentIndex )
+ && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ }
+
+ bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t attachmentIndex;
+ SampleLocationsInfoEXT sampleLocationsInfo;
+ };
+ static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
+
+ struct SubpassSampleLocationsEXT
+ {
+ SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
+ SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+ : subpassIndex( subpassIndex_ )
+ , sampleLocationsInfo( sampleLocationsInfo_ )
+ {
+ }
+
+ SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+ }
+
+ SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+ return *this;
+ }
+ SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ )
+ {
+ subpassIndex = subpassIndex_;
+ return *this;
+ }
+
+ SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ {
+ sampleLocationsInfo = sampleLocationsInfo_;
+ return *this;
+ }
+
+ operator VkSubpassSampleLocationsEXT const&() const
+ {
+ return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this);
+ }
+
+ operator VkSubpassSampleLocationsEXT &()
+ {
+ return *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this);
+ }
+
+ bool operator==( SubpassSampleLocationsEXT const& rhs ) const
+ {
+ return ( subpassIndex == rhs.subpassIndex )
+ && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ }
+
+ bool operator!=( SubpassSampleLocationsEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t subpassIndex;
+ SampleLocationsInfoEXT sampleLocationsInfo;
+ };
+ static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
+
+ struct RenderPassSampleLocationsBeginInfoEXT
+ {
+ RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
+ const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
+ uint32_t postSubpassSampleLocationsCount_ = 0,
+ const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
+ : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+ , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
+ , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
+ , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+ {
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+ return *this;
+ }
+ RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ )
+ {
+ attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
+ return *this;
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
+ {
+ pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
+ return *this;
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ )
+ {
+ postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
+ return *this;
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
+ {
+ pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
+ return *this;
+ }
+
+ operator VkRenderPassSampleLocationsBeginInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this);
+ }
+
+ operator VkRenderPassSampleLocationsBeginInfoEXT &()
+ {
+ return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this);
+ }
+
+ bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount )
+ && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations )
+ && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount )
+ && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+ }
+
+ bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t attachmentInitialSampleLocationsCount;
+ const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
+ uint32_t postSubpassSampleLocationsCount;
+ const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+ };
+ static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
+
+ struct PipelineSampleLocationsStateCreateInfoEXT
+ {
+ PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0,
+ SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+ : sampleLocationsEnable( sampleLocationsEnable_ )
+ , sampleLocationsInfo( sampleLocationsInfo_ )
+ {
+ }
+
+ PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+ }
+
+ PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+ return *this;
+ }
+ PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
+ {
+ sampleLocationsEnable = sampleLocationsEnable_;
+ return *this;
+ }
+
+ PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ {
+ sampleLocationsInfo = sampleLocationsInfo_;
+ return *this;
+ }
+
+ operator VkPipelineSampleLocationsStateCreateInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
+ }
+
+ operator VkPipelineSampleLocationsStateCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
+ }
+
+ bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( sampleLocationsEnable == rhs.sampleLocationsEnable )
+ && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ }
+
+ bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ Bool32 sampleLocationsEnable;
+ SampleLocationsInfoEXT sampleLocationsInfo;
+ };
+ static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
+ struct PhysicalDeviceSampleLocationsPropertiesEXT
+ {
+ operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+ }
+
+ operator VkPhysicalDeviceSampleLocationsPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+ }
+
+ bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts )
+ && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize )
+ && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 )
+ && ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits )
+ && ( variableSampleLocations == rhs.variableSampleLocations );
+ }
+
+ bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
+
+ public:
+ void* pNext = nullptr;
+ SampleCountFlags sampleLocationSampleCounts;
+ Extent2D maxSampleLocationGridSize;
+ float sampleLocationCoordinateRange[2];
+ uint32_t sampleLocationSubPixelBits;
+ Bool32 variableSampleLocations;
+ };
+ static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
+
+ enum class AttachmentDescriptionFlagBits
+ {
+ eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+ };
+
+ using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
+
+ VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
+ {
+ return ~( AttachmentDescriptionFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<AttachmentDescriptionFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
+ };
+ };
+
+ struct AttachmentDescription
+ {
+ AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
+ Format format_ = Format::eUndefined,
+ SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+ AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
+ AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
+ AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
+ AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
+ ImageLayout initialLayout_ = ImageLayout::eUndefined,
+ ImageLayout finalLayout_ = ImageLayout::eUndefined )
+ : flags( flags_ )
+ , format( format_ )
+ , samples( samples_ )
+ , loadOp( loadOp_ )
+ , storeOp( storeOp_ )
+ , stencilLoadOp( stencilLoadOp_ )
+ , stencilStoreOp( stencilStoreOp_ )
+ , initialLayout( initialLayout_ )
+ , finalLayout( finalLayout_ )
+ {
+ }
+
+ AttachmentDescription( VkAttachmentDescription const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentDescription ) );
+ }
+
+ AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentDescription ) );
+ return *this;
+ }
+ AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ AttachmentDescription& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
+ {
+ loadOp = loadOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
+ {
+ storeOp = storeOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ {
+ stencilLoadOp = stencilLoadOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ {
+ stencilStoreOp = stencilStoreOp_;
+ return *this;
+ }
+
+ AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
+ {
+ initialLayout = initialLayout_;
+ return *this;
+ }
+
+ AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
+ {
+ finalLayout = finalLayout_;
+ return *this;
+ }
+
+ operator VkAttachmentDescription const&() const
+ {
+ return *reinterpret_cast<const VkAttachmentDescription*>(this);
+ }
+
+ operator VkAttachmentDescription &()
+ {
+ return *reinterpret_cast<VkAttachmentDescription*>(this);
+ }
+
+ bool operator==( AttachmentDescription const& rhs ) const
+ {
+ return ( flags == rhs.flags )
+ && ( format == rhs.format )
+ && ( samples == rhs.samples )
+ && ( loadOp == rhs.loadOp )
+ && ( storeOp == rhs.storeOp )
+ && ( stencilLoadOp == rhs.stencilLoadOp )
+ && ( stencilStoreOp == rhs.stencilStoreOp )
+ && ( initialLayout == rhs.initialLayout )
+ && ( finalLayout == rhs.finalLayout );
+ }
+
+ bool operator!=( AttachmentDescription const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ AttachmentDescriptionFlags flags;
+ Format format;
+ SampleCountFlagBits samples;
+ AttachmentLoadOp loadOp;
+ AttachmentStoreOp storeOp;
+ AttachmentLoadOp stencilLoadOp;
+ AttachmentStoreOp stencilStoreOp;
+ ImageLayout initialLayout;
+ ImageLayout finalLayout;
+ };
+ static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
+
+ struct AttachmentDescription2KHR
+ {
+ AttachmentDescription2KHR( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
+ Format format_ = Format::eUndefined,
+ SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+ AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
+ AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
+ AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
+ AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
+ ImageLayout initialLayout_ = ImageLayout::eUndefined,
+ ImageLayout finalLayout_ = ImageLayout::eUndefined )
+ : flags( flags_ )
+ , format( format_ )
+ , samples( samples_ )
+ , loadOp( loadOp_ )
+ , storeOp( storeOp_ )
+ , stencilLoadOp( stencilLoadOp_ )
+ , stencilStoreOp( stencilStoreOp_ )
+ , initialLayout( initialLayout_ )
+ , finalLayout( finalLayout_ )
+ {
+ }
+
+ AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
+ }
+
+ AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
+ return *this;
+ }
+ AttachmentDescription2KHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setFlags( AttachmentDescriptionFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setFormat( Format format_ )
+ {
+ format = format_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setSamples( SampleCountFlagBits samples_ )
+ {
+ samples = samples_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setLoadOp( AttachmentLoadOp loadOp_ )
+ {
+ loadOp = loadOp_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setStoreOp( AttachmentStoreOp storeOp_ )
+ {
+ storeOp = storeOp_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ {
+ stencilLoadOp = stencilLoadOp_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ {
+ stencilStoreOp = stencilStoreOp_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setInitialLayout( ImageLayout initialLayout_ )
+ {
+ initialLayout = initialLayout_;
+ return *this;
+ }
+
+ AttachmentDescription2KHR& setFinalLayout( ImageLayout finalLayout_ )
+ {
+ finalLayout = finalLayout_;
+ return *this;
+ }
+
+ operator VkAttachmentDescription2KHR const&() const
+ {
+ return *reinterpret_cast<const VkAttachmentDescription2KHR*>(this);
+ }
+
+ operator VkAttachmentDescription2KHR &()
+ {
+ return *reinterpret_cast<VkAttachmentDescription2KHR*>(this);
+ }
+
+ bool operator==( AttachmentDescription2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( format == rhs.format )
+ && ( samples == rhs.samples )
+ && ( loadOp == rhs.loadOp )
+ && ( storeOp == rhs.storeOp )
+ && ( stencilLoadOp == rhs.stencilLoadOp )
+ && ( stencilStoreOp == rhs.stencilStoreOp )
+ && ( initialLayout == rhs.initialLayout )
+ && ( finalLayout == rhs.finalLayout );
+ }
+
+ bool operator!=( AttachmentDescription2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eAttachmentDescription2KHR;
+
+ public:
+ const void* pNext = nullptr;
+ AttachmentDescriptionFlags flags;
+ Format format;
+ SampleCountFlagBits samples;
+ AttachmentLoadOp loadOp;
+ AttachmentStoreOp storeOp;
+ AttachmentLoadOp stencilLoadOp;
+ AttachmentStoreOp stencilStoreOp;
+ ImageLayout initialLayout;
+ ImageLayout finalLayout;
+ };
+ static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
+
+ enum class StencilFaceFlagBits
+ {
+ eFront = VK_STENCIL_FACE_FRONT_BIT,
+ eBack = VK_STENCIL_FACE_BACK_BIT,
+ eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
+ };
+
+ using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
+
+ VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
+ {
+ return ~( StencilFaceFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<StencilFaceFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
+ };
+ };
+
+ enum class DescriptorPoolCreateFlagBits
+ {
+ eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+ eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
+ };
+
+ using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
+
+ VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
+ {
+ return ~( DescriptorPoolCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT)
+ };
+ };
+
+ struct DescriptorPoolCreateInfo
+ {
+ DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(),
+ uint32_t maxSets_ = 0,
+ uint32_t poolSizeCount_ = 0,
+ const DescriptorPoolSize* pPoolSizes_ = nullptr )
+ : flags( flags_ )
+ , maxSets( maxSets_ )
+ , poolSizeCount( poolSizeCount_ )
+ , pPoolSizes( pPoolSizes_ )
+ {
+ }
+
+ DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+ }
+
+ DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+ return *this;
+ }
+ DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
+ {
+ maxSets = maxSets_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
+ {
+ poolSizeCount = poolSizeCount_;
+ return *this;
+ }
+
+ DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
+ {
+ pPoolSizes = pPoolSizes_;
+ return *this;
+ }
+
+ operator VkDescriptorPoolCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
+ }
+
+ operator VkDescriptorPoolCreateInfo &()
+ {
+ return *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this);
+ }
+
+ bool operator==( DescriptorPoolCreateInfo const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( maxSets == rhs.maxSets )
+ && ( poolSizeCount == rhs.poolSizeCount )
+ && ( pPoolSizes == rhs.pPoolSizes );
+ }
+
+ bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eDescriptorPoolCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ DescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+ uint32_t poolSizeCount;
+ const DescriptorPoolSize* pPoolSizes;
+ };
+ static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
+
+ enum class DependencyFlagBits
+ {
+ eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
+ eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT,
+ eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
+ eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT,
+ eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT
+ };
+
+ using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
+
+ VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
+ {
+ return ~( DependencyFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<DependencyFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eDeviceGroup) | VkFlags(DependencyFlagBits::eViewLocal)
+ };
+ };
+
+ struct SubpassDependency
+ {
+ SubpassDependency( uint32_t srcSubpass_ = 0,
+ uint32_t dstSubpass_ = 0,
+ PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
+ PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
+ AccessFlags srcAccessMask_ = AccessFlags(),
+ AccessFlags dstAccessMask_ = AccessFlags(),
+ DependencyFlags dependencyFlags_ = DependencyFlags() )
+ : srcSubpass( srcSubpass_ )
+ , dstSubpass( dstSubpass_ )
+ , srcStageMask( srcStageMask_ )
+ , dstStageMask( dstStageMask_ )
+ , srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , dependencyFlags( dependencyFlags_ )
+ {
+ }
+
+ SubpassDependency( VkSubpassDependency const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SubpassDependency ) );
+ }
+
+ SubpassDependency& operator=( VkSubpassDependency const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SubpassDependency ) );
+ return *this;
+ }
+ SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
+ {
+ srcSubpass = srcSubpass_;
+ return *this;
+ }
+
+ SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
+ {
+ dstSubpass = dstSubpass_;
+ return *this;
+ }
+
+ SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ {
+ srcStageMask = srcStageMask_;
+ return *this;
+ }
+
+ SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
+ {
+ dstStageMask = dstStageMask_;
+ return *this;
+ }
+
+ SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ {
+ srcAccessMask = srcAccessMask_;
+ return *this;
+ }
+
+ SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
+ {
+ dstAccessMask = dstAccessMask_;
+ return *this;
+ }
+
+ SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
+ {
+ dependencyFlags = dependencyFlags_;
+ return *this;
+ }
+
+ operator VkSubpassDependency const&() const
+ {
+ return *reinterpret_cast<const VkSubpassDependency*>(this);
+ }
+
+ operator VkSubpassDependency &()
+ {
+ return *reinterpret_cast<VkSubpassDependency*>(this);
+ }
+
+ bool operator==( SubpassDependency const& rhs ) const
+ {
+ return ( srcSubpass == rhs.srcSubpass )
+ && ( dstSubpass == rhs.dstSubpass )
+ && ( srcStageMask == rhs.srcStageMask )
+ && ( dstStageMask == rhs.dstStageMask )
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( dependencyFlags == rhs.dependencyFlags );
+ }
+
+ bool operator!=( SubpassDependency const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ PipelineStageFlags srcStageMask;
+ PipelineStageFlags dstStageMask;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ DependencyFlags dependencyFlags;
+ };
+ static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
+
+ struct SubpassDependency2KHR
+ {
+ SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
+ uint32_t dstSubpass_ = 0,
+ PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
+ PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
+ AccessFlags srcAccessMask_ = AccessFlags(),
+ AccessFlags dstAccessMask_ = AccessFlags(),
+ DependencyFlags dependencyFlags_ = DependencyFlags(),
+ int32_t viewOffset_ = 0 )
+ : srcSubpass( srcSubpass_ )
+ , dstSubpass( dstSubpass_ )
+ , srcStageMask( srcStageMask_ )
+ , dstStageMask( dstStageMask_ )
+ , srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , dependencyFlags( dependencyFlags_ )
+ , viewOffset( viewOffset_ )
+ {
+ }
+
+ SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
+ }
+
+ SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
+ return *this;
+ }
+ SubpassDependency2KHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setSrcSubpass( uint32_t srcSubpass_ )
+ {
+ srcSubpass = srcSubpass_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setDstSubpass( uint32_t dstSubpass_ )
+ {
+ dstSubpass = dstSubpass_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ {
+ srcStageMask = srcStageMask_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setDstStageMask( PipelineStageFlags dstStageMask_ )
+ {
+ dstStageMask = dstStageMask_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ {
+ srcAccessMask = srcAccessMask_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setDstAccessMask( AccessFlags dstAccessMask_ )
+ {
+ dstAccessMask = dstAccessMask_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setDependencyFlags( DependencyFlags dependencyFlags_ )
+ {
+ dependencyFlags = dependencyFlags_;
+ return *this;
+ }
+
+ SubpassDependency2KHR& setViewOffset( int32_t viewOffset_ )
+ {
+ viewOffset = viewOffset_;
+ return *this;
+ }
+
+ operator VkSubpassDependency2KHR const&() const
+ {
+ return *reinterpret_cast<const VkSubpassDependency2KHR*>(this);
+ }
+
+ operator VkSubpassDependency2KHR &()
+ {
+ return *reinterpret_cast<VkSubpassDependency2KHR*>(this);
+ }
+
+ bool operator==( SubpassDependency2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( srcSubpass == rhs.srcSubpass )
+ && ( dstSubpass == rhs.dstSubpass )
+ && ( srcStageMask == rhs.srcStageMask )
+ && ( dstStageMask == rhs.dstStageMask )
+ && ( srcAccessMask == rhs.srcAccessMask )
+ && ( dstAccessMask == rhs.dstAccessMask )
+ && ( dependencyFlags == rhs.dependencyFlags )
+ && ( viewOffset == rhs.viewOffset );
+ }
+
+ bool operator!=( SubpassDependency2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eSubpassDependency2KHR;
+
+ public:
+ const void* pNext = nullptr;
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ PipelineStageFlags srcStageMask;
+ PipelineStageFlags dstStageMask;
+ AccessFlags srcAccessMask;
+ AccessFlags dstAccessMask;
+ DependencyFlags dependencyFlags;
+ int32_t viewOffset;
+ };
+ static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
+
+ enum class PresentModeKHR
+ {
+ eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
+ eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
+ eFifo = VK_PRESENT_MODE_FIFO_KHR,
+ eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+ eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
+ eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
+ };
+
+ enum class ColorSpaceKHR
+ {
+ eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+ eVkColorspaceSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+ eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
+ eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
+ eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
+ eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
+ eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
+ eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
+ eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
+ eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
+ eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
+ eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
+ eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
+ eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
+ ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
+ eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT
+ };
+
+ struct SurfaceFormatKHR
+ {
+ operator VkSurfaceFormatKHR const&() const
+ {
+ return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
+ }
+
+ operator VkSurfaceFormatKHR &()
+ {
+ return *reinterpret_cast<VkSurfaceFormatKHR*>(this);
+ }
+
+ bool operator==( SurfaceFormatKHR const& rhs ) const
+ {
+ return ( format == rhs.format )
+ && ( colorSpace == rhs.colorSpace );
+ }
+
+ bool operator!=( SurfaceFormatKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ Format format;
+ ColorSpaceKHR colorSpace;
+ };
+ static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
+
+ struct SurfaceFormat2KHR
+ {
+ operator VkSurfaceFormat2KHR const&() const
+ {
+ return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
+ }
+
+ operator VkSurfaceFormat2KHR &()
+ {
+ return *reinterpret_cast<VkSurfaceFormat2KHR*>(this);
+ }
+
+ bool operator==( SurfaceFormat2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( surfaceFormat == rhs.surfaceFormat );
+ }
+
+ bool operator!=( SurfaceFormat2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eSurfaceFormat2KHR;
+
+ public:
+ void* pNext = nullptr;
+ SurfaceFormatKHR surfaceFormat;
+ };
+ static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
+
+ enum class DisplayPlaneAlphaFlagBitsKHR
+ {
+ eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
+ eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
+ ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
+ ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
+ };
+
+ using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
+
+ VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
+ {
+ return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
+ };
+ };
+
+ struct DisplayPlaneCapabilitiesKHR
+ {
+ operator VkDisplayPlaneCapabilitiesKHR const&() const
+ {
+ return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
+ }
+
+ operator VkDisplayPlaneCapabilitiesKHR &()
+ {
+ return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this);
+ }
+
+ bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ {
+ return ( supportedAlpha == rhs.supportedAlpha )
+ && ( minSrcPosition == rhs.minSrcPosition )
+ && ( maxSrcPosition == rhs.maxSrcPosition )
+ && ( minSrcExtent == rhs.minSrcExtent )
+ && ( maxSrcExtent == rhs.maxSrcExtent )
+ && ( minDstPosition == rhs.minDstPosition )
+ && ( maxDstPosition == rhs.maxDstPosition )
+ && ( minDstExtent == rhs.minDstExtent )
+ && ( maxDstExtent == rhs.maxDstExtent );
+ }
+
+ bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DisplayPlaneAlphaFlagsKHR supportedAlpha;
+ Offset2D minSrcPosition;
+ Offset2D maxSrcPosition;
+ Extent2D minSrcExtent;
+ Extent2D maxSrcExtent;
+ Offset2D minDstPosition;
+ Offset2D maxDstPosition;
+ Extent2D minDstExtent;
+ Extent2D maxDstExtent;
+ };
+ static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+ struct DisplayPlaneCapabilities2KHR
+ {
+ operator VkDisplayPlaneCapabilities2KHR const&() const
+ {
+ return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(this);
+ }
+
+ operator VkDisplayPlaneCapabilities2KHR &()
+ {
+ return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this);
+ }
+
+ bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( capabilities == rhs.capabilities );
+ }
+
+ bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
+
+ public:
+ void* pNext = nullptr;
+ DisplayPlaneCapabilitiesKHR capabilities;
+ };
+ static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
+
+ enum class CompositeAlphaFlagBitsKHR
+ {
+ eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+ ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+ ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+ eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
+ };
+
+ using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
+
+ VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
+ {
+ return ~( CompositeAlphaFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
+ };
+ };
+
+ enum class SurfaceTransformFlagBitsKHR
+ {
+ eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
+ eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
+ eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
+ eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
+ eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
+ eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
+ eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
+ eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
+ eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
+ };
+
+ using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
+
+ VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
+ {
+ return ~( SurfaceTransformFlagsKHR( bits ) );
+ }
+
+ template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
+ };
+ };
+
+ struct DisplayPropertiesKHR
+ {
+ operator VkDisplayPropertiesKHR const&() const
+ {
+ return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
+ }
+
+ operator VkDisplayPropertiesKHR &()
+ {
+ return *reinterpret_cast<VkDisplayPropertiesKHR*>(this);
+ }
+
+ bool operator==( DisplayPropertiesKHR const& rhs ) const
+ {
+ return ( display == rhs.display )
+ && ( displayName == rhs.displayName )
+ && ( physicalDimensions == rhs.physicalDimensions )
+ && ( physicalResolution == rhs.physicalResolution )
+ && ( supportedTransforms == rhs.supportedTransforms )
+ && ( planeReorderPossible == rhs.planeReorderPossible )
+ && ( persistentContent == rhs.persistentContent );
+ }
+
+ bool operator!=( DisplayPropertiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ DisplayKHR display;
+ const char* displayName;
+ Extent2D physicalDimensions;
+ Extent2D physicalResolution;
+ SurfaceTransformFlagsKHR supportedTransforms;
+ Bool32 planeReorderPossible;
+ Bool32 persistentContent;
+ };
+ static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
+
+ struct DisplaySurfaceCreateInfoKHR
+ {
+ DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(),
+ DisplayModeKHR displayMode_ = DisplayModeKHR(),
+ uint32_t planeIndex_ = 0,
+ uint32_t planeStackIndex_ = 0,
+ SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity,
+ float globalAlpha_ = 0,
+ DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque,
+ Extent2D imageExtent_ = Extent2D() )
+ : flags( flags_ )
+ , displayMode( displayMode_ )
+ , planeIndex( planeIndex_ )
+ , planeStackIndex( planeStackIndex_ )
+ , transform( transform_ )
+ , globalAlpha( globalAlpha_ )
+ , alphaMode( alphaMode_ )
+ , imageExtent( imageExtent_ )
+ {
+ }
+
+ DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+ }
+
+ DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+ return *this;
+ }
+ DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+ DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
{
- pDynamicState = pDynamicState_;
+ flags = flags_;
return *this;
}
- GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
+ DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
{
- layout = layout_;
+ displayMode = displayMode_;
return *this;
}
- GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
+ DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
{
- renderPass = renderPass_;
+ planeIndex = planeIndex_;
return *this;
}
- GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
+ DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
{
- subpass = subpass_;
+ planeStackIndex = planeStackIndex_;
return *this;
}
- GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
{
- basePipelineHandle = basePipelineHandle_;
+ transform = transform_;
return *this;
}
- GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
+ DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
{
- basePipelineIndex = basePipelineIndex_;
+ globalAlpha = globalAlpha_;
return *this;
}
- operator const VkGraphicsPipelineCreateInfo&() const
+ DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
{
- return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
+ alphaMode = alphaMode_;
+ return *this;
}
- bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
+ DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ {
+ imageExtent = imageExtent_;
+ return *this;
+ }
+
+ operator VkDisplaySurfaceCreateInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
+ }
+
+ operator VkDisplaySurfaceCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this);
+ }
+
+ bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( stageCount == rhs.stageCount )
- && ( pStages == rhs.pStages )
- && ( pVertexInputState == rhs.pVertexInputState )
- && ( pInputAssemblyState == rhs.pInputAssemblyState )
- && ( pTessellationState == rhs.pTessellationState )
- && ( pViewportState == rhs.pViewportState )
- && ( pRasterizationState == rhs.pRasterizationState )
- && ( pMultisampleState == rhs.pMultisampleState )
- && ( pDepthStencilState == rhs.pDepthStencilState )
- && ( pColorBlendState == rhs.pColorBlendState )
- && ( pDynamicState == rhs.pDynamicState )
- && ( layout == rhs.layout )
- && ( renderPass == rhs.renderPass )
- && ( subpass == rhs.subpass )
- && ( basePipelineHandle == rhs.basePipelineHandle )
- && ( basePipelineIndex == rhs.basePipelineIndex );
+ && ( displayMode == rhs.displayMode )
+ && ( planeIndex == rhs.planeIndex )
+ && ( planeStackIndex == rhs.planeStackIndex )
+ && ( transform == rhs.transform )
+ && ( globalAlpha == rhs.globalAlpha )
+ && ( alphaMode == rhs.alphaMode )
+ && ( imageExtent == rhs.imageExtent );
}
- bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
+ bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
+ StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
public:
const void* pNext = nullptr;
- PipelineCreateFlags flags;
- uint32_t stageCount;
- const PipelineShaderStageCreateInfo* pStages;
- const PipelineVertexInputStateCreateInfo* pVertexInputState;
- const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
- const PipelineTessellationStateCreateInfo* pTessellationState;
- const PipelineViewportStateCreateInfo* pViewportState;
- const PipelineRasterizationStateCreateInfo* pRasterizationState;
- const PipelineMultisampleStateCreateInfo* pMultisampleState;
- const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
- const PipelineColorBlendStateCreateInfo* pColorBlendState;
- const PipelineDynamicStateCreateInfo* pDynamicState;
- PipelineLayout layout;
- RenderPass renderPass;
- uint32_t subpass;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
+ DisplaySurfaceCreateFlagsKHR flags;
+ DisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+ SurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+ DisplayPlaneAlphaFlagBitsKHR alphaMode;
+ Extent2D imageExtent;
};
- static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
- struct PhysicalDeviceLimits
+ struct SurfaceCapabilitiesKHR
{
- operator const VkPhysicalDeviceLimits&() const
+ operator VkSurfaceCapabilitiesKHR const&() const
{
- return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
+ return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
}
- bool operator==( PhysicalDeviceLimits const& rhs ) const
+ operator VkSurfaceCapabilitiesKHR &()
{
- return ( maxImageDimension1D == rhs.maxImageDimension1D )
- && ( maxImageDimension2D == rhs.maxImageDimension2D )
- && ( maxImageDimension3D == rhs.maxImageDimension3D )
- && ( maxImageDimensionCube == rhs.maxImageDimensionCube )
+ return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this);
+ }
+
+ bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
+ {
+ return ( minImageCount == rhs.minImageCount )
+ && ( maxImageCount == rhs.maxImageCount )
+ && ( currentExtent == rhs.currentExtent )
+ && ( minImageExtent == rhs.minImageExtent )
+ && ( maxImageExtent == rhs.maxImageExtent )
&& ( maxImageArrayLayers == rhs.maxImageArrayLayers )
- && ( maxTexelBufferElements == rhs.maxTexelBufferElements )
- && ( maxUniformBufferRange == rhs.maxUniformBufferRange )
- && ( maxStorageBufferRange == rhs.maxStorageBufferRange )
- && ( maxPushConstantsSize == rhs.maxPushConstantsSize )
- && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount )
- && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount )
- && ( bufferImageGranularity == rhs.bufferImageGranularity )
- && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize )
- && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets )
- && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers )
- && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers )
- && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers )
- && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages )
- && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages )
- && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments )
- && ( maxPerStageResources == rhs.maxPerStageResources )
- && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers )
- && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers )
- && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic )
- && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers )
- && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic )
- && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages )
- && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages )
- && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments )
- && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes )
- && ( maxVertexInputBindings == rhs.maxVertexInputBindings )
- && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset )
- && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride )
- && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents )
- && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel )
- && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize )
- && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents )
- && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents )
- && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents )
- && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents )
- && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents )
- && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents )
- && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations )
- && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents )
- && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents )
- && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices )
- && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents )
- && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents )
- && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments )
- && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
- && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
- && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
- && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
- && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
- && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
- && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
- && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
- && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
- && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue )
- && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount )
- && ( maxSamplerLodBias == rhs.maxSamplerLodBias )
- && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy )
- && ( maxViewports == rhs.maxViewports )
- && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
- && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
- && ( viewportSubPixelBits == rhs.viewportSubPixelBits )
- && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
- && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
- && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment )
- && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment )
- && ( minTexelOffset == rhs.minTexelOffset )
- && ( maxTexelOffset == rhs.maxTexelOffset )
- && ( minTexelGatherOffset == rhs.minTexelGatherOffset )
- && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset )
- && ( minInterpolationOffset == rhs.minInterpolationOffset )
- && ( maxInterpolationOffset == rhs.maxInterpolationOffset )
- && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits )
- && ( maxFramebufferWidth == rhs.maxFramebufferWidth )
- && ( maxFramebufferHeight == rhs.maxFramebufferHeight )
- && ( maxFramebufferLayers == rhs.maxFramebufferLayers )
- && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts )
- && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts )
- && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts )
- && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts )
- && ( maxColorAttachments == rhs.maxColorAttachments )
- && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts )
- && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts )
- && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts )
- && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts )
- && ( storageImageSampleCounts == rhs.storageImageSampleCounts )
- && ( maxSampleMaskWords == rhs.maxSampleMaskWords )
- && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics )
- && ( timestampPeriod == rhs.timestampPeriod )
- && ( maxClipDistances == rhs.maxClipDistances )
- && ( maxCullDistances == rhs.maxCullDistances )
- && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances )
- && ( discreteQueuePriorities == rhs.discreteQueuePriorities )
- && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
- && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
- && ( pointSizeGranularity == rhs.pointSizeGranularity )
- && ( lineWidthGranularity == rhs.lineWidthGranularity )
- && ( strictLines == rhs.strictLines )
- && ( standardSampleLocations == rhs.standardSampleLocations )
- && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment )
- && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment )
- && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+ && ( supportedTransforms == rhs.supportedTransforms )
+ && ( currentTransform == rhs.currentTransform )
+ && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
+ && ( supportedUsageFlags == rhs.supportedUsageFlags );
}
- bool operator!=( PhysicalDeviceLimits const& rhs ) const
+ bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t maxImageDimension1D;
- uint32_t maxImageDimension2D;
- uint32_t maxImageDimension3D;
- uint32_t maxImageDimensionCube;
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ Extent2D currentExtent;
+ Extent2D minImageExtent;
+ Extent2D maxImageExtent;
uint32_t maxImageArrayLayers;
- uint32_t maxTexelBufferElements;
- uint32_t maxUniformBufferRange;
- uint32_t maxStorageBufferRange;
- uint32_t maxPushConstantsSize;
- uint32_t maxMemoryAllocationCount;
- uint32_t maxSamplerAllocationCount;
- DeviceSize bufferImageGranularity;
- DeviceSize sparseAddressSpaceSize;
- uint32_t maxBoundDescriptorSets;
- uint32_t maxPerStageDescriptorSamplers;
- uint32_t maxPerStageDescriptorUniformBuffers;
- uint32_t maxPerStageDescriptorStorageBuffers;
- uint32_t maxPerStageDescriptorSampledImages;
- uint32_t maxPerStageDescriptorStorageImages;
- uint32_t maxPerStageDescriptorInputAttachments;
- uint32_t maxPerStageResources;
- uint32_t maxDescriptorSetSamplers;
- uint32_t maxDescriptorSetUniformBuffers;
- uint32_t maxDescriptorSetUniformBuffersDynamic;
- uint32_t maxDescriptorSetStorageBuffers;
- uint32_t maxDescriptorSetStorageBuffersDynamic;
- uint32_t maxDescriptorSetSampledImages;
- uint32_t maxDescriptorSetStorageImages;
- uint32_t maxDescriptorSetInputAttachments;
- uint32_t maxVertexInputAttributes;
- uint32_t maxVertexInputBindings;
- uint32_t maxVertexInputAttributeOffset;
- uint32_t maxVertexInputBindingStride;
- uint32_t maxVertexOutputComponents;
- uint32_t maxTessellationGenerationLevel;
- uint32_t maxTessellationPatchSize;
- uint32_t maxTessellationControlPerVertexInputComponents;
- uint32_t maxTessellationControlPerVertexOutputComponents;
- uint32_t maxTessellationControlPerPatchOutputComponents;
- uint32_t maxTessellationControlTotalOutputComponents;
- uint32_t maxTessellationEvaluationInputComponents;
- uint32_t maxTessellationEvaluationOutputComponents;
- uint32_t maxGeometryShaderInvocations;
- uint32_t maxGeometryInputComponents;
- uint32_t maxGeometryOutputComponents;
- uint32_t maxGeometryOutputVertices;
- uint32_t maxGeometryTotalOutputComponents;
- uint32_t maxFragmentInputComponents;
- uint32_t maxFragmentOutputAttachments;
- uint32_t maxFragmentDualSrcAttachments;
- uint32_t maxFragmentCombinedOutputResources;
- uint32_t maxComputeSharedMemorySize;
- uint32_t maxComputeWorkGroupCount[3];
- uint32_t maxComputeWorkGroupInvocations;
- uint32_t maxComputeWorkGroupSize[3];
- uint32_t subPixelPrecisionBits;
- uint32_t subTexelPrecisionBits;
- uint32_t mipmapPrecisionBits;
- uint32_t maxDrawIndexedIndexValue;
- uint32_t maxDrawIndirectCount;
- float maxSamplerLodBias;
- float maxSamplerAnisotropy;
- uint32_t maxViewports;
- uint32_t maxViewportDimensions[2];
- float viewportBoundsRange[2];
- uint32_t viewportSubPixelBits;
- size_t minMemoryMapAlignment;
- DeviceSize minTexelBufferOffsetAlignment;
- DeviceSize minUniformBufferOffsetAlignment;
- DeviceSize minStorageBufferOffsetAlignment;
- int32_t minTexelOffset;
- uint32_t maxTexelOffset;
- int32_t minTexelGatherOffset;
- uint32_t maxTexelGatherOffset;
- float minInterpolationOffset;
- float maxInterpolationOffset;
- uint32_t subPixelInterpolationOffsetBits;
- uint32_t maxFramebufferWidth;
- uint32_t maxFramebufferHeight;
- uint32_t maxFramebufferLayers;
- SampleCountFlags framebufferColorSampleCounts;
- SampleCountFlags framebufferDepthSampleCounts;
- SampleCountFlags framebufferStencilSampleCounts;
- SampleCountFlags framebufferNoAttachmentsSampleCounts;
- uint32_t maxColorAttachments;
- SampleCountFlags sampledImageColorSampleCounts;
- SampleCountFlags sampledImageIntegerSampleCounts;
- SampleCountFlags sampledImageDepthSampleCounts;
- SampleCountFlags sampledImageStencilSampleCounts;
- SampleCountFlags storageImageSampleCounts;
- uint32_t maxSampleMaskWords;
- Bool32 timestampComputeAndGraphics;
- float timestampPeriod;
- uint32_t maxClipDistances;
- uint32_t maxCullDistances;
- uint32_t maxCombinedClipAndCullDistances;
- uint32_t discreteQueuePriorities;
- float pointSizeRange[2];
- float lineWidthRange[2];
- float pointSizeGranularity;
- float lineWidthGranularity;
- Bool32 strictLines;
- Bool32 standardSampleLocations;
- DeviceSize optimalBufferCopyOffsetAlignment;
- DeviceSize optimalBufferCopyRowPitchAlignment;
- DeviceSize nonCoherentAtomSize;
+ SurfaceTransformFlagsKHR supportedTransforms;
+ SurfaceTransformFlagBitsKHR currentTransform;
+ CompositeAlphaFlagsKHR supportedCompositeAlpha;
+ ImageUsageFlags supportedUsageFlags;
};
- static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
-
- struct PhysicalDeviceProperties
- {
- operator const VkPhysicalDeviceProperties&() const
- {
- return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
- }
-
- bool operator==( PhysicalDeviceProperties const& rhs ) const
- {
- return ( apiVersion == rhs.apiVersion )
- && ( driverVersion == rhs.driverVersion )
- && ( vendorID == rhs.vendorID )
- && ( deviceID == rhs.deviceID )
- && ( deviceType == rhs.deviceType )
- && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
- && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
- && ( limits == rhs.limits )
- && ( sparseProperties == rhs.sparseProperties );
- }
+ static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
- bool operator!=( PhysicalDeviceProperties const& rhs ) const
+ struct SurfaceCapabilities2KHR
+ {
+ operator VkSurfaceCapabilities2KHR const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
}
- uint32_t apiVersion;
- uint32_t driverVersion;
- uint32_t vendorID;
- uint32_t deviceID;
- PhysicalDeviceType deviceType;
- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
- uint8_t pipelineCacheUUID[VK_UUID_SIZE];
- PhysicalDeviceLimits limits;
- PhysicalDeviceSparseProperties sparseProperties;
- };
- static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
-
- struct PhysicalDeviceProperties2
- {
- operator const VkPhysicalDeviceProperties2&() const
+ operator VkSurfaceCapabilities2KHR &()
{
- return *reinterpret_cast<const VkPhysicalDeviceProperties2*>(this);
+ return *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this);
}
- bool operator==( PhysicalDeviceProperties2 const& rhs ) const
+ bool operator==( SurfaceCapabilities2KHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( properties == rhs.properties );
+ && ( surfaceCapabilities == rhs.surfaceCapabilities );
}
- bool operator!=( PhysicalDeviceProperties2 const& rhs ) const
+ bool operator!=( SurfaceCapabilities2KHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceProperties2;
+ StructureType sType = StructureType::eSurfaceCapabilities2KHR;
public:
void* pNext = nullptr;
- PhysicalDeviceProperties properties;
+ SurfaceCapabilitiesKHR surfaceCapabilities;
};
- static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
-
- using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
+ static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
- struct ImageFormatProperties2
+ struct DisplayProperties2KHR
{
- operator const VkImageFormatProperties2&() const
+ operator VkDisplayProperties2KHR const&() const
{
- return *reinterpret_cast<const VkImageFormatProperties2*>(this);
+ return *reinterpret_cast<const VkDisplayProperties2KHR*>(this);
}
- bool operator==( ImageFormatProperties2 const& rhs ) const
+ operator VkDisplayProperties2KHR &()
+ {
+ return *reinterpret_cast<VkDisplayProperties2KHR*>(this);
+ }
+
+ bool operator==( DisplayProperties2KHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( imageFormatProperties == rhs.imageFormatProperties );
+ && ( displayProperties == rhs.displayProperties );
}
- bool operator!=( ImageFormatProperties2 const& rhs ) const
+ bool operator!=( DisplayProperties2KHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImageFormatProperties2;
+ StructureType sType = StructureType::eDisplayProperties2KHR;
public:
void* pNext = nullptr;
- ImageFormatProperties imageFormatProperties;
+ DisplayPropertiesKHR displayProperties;
};
- static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
- using ImageFormatProperties2KHR = ImageFormatProperties2;
+ enum class TimeDomainEXT
+ {
+ eDevice = VK_TIME_DOMAIN_DEVICE_EXT,
+ eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT,
+ eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT,
+ eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT
+ };
- struct PhysicalDeviceSparseImageFormatInfo2
+ struct CalibratedTimestampInfoEXT
{
- PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined,
- ImageType type_ = ImageType::e1D,
- SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
- ImageUsageFlags usage_ = ImageUsageFlags(),
- ImageTiling tiling_ = ImageTiling::eOptimal )
- : format( format_ )
- , type( type_ )
- , samples( samples_ )
- , usage( usage_ )
- , tiling( tiling_ )
+ CalibratedTimestampInfoEXT( TimeDomainEXT timeDomain_ = TimeDomainEXT::eDevice )
+ : timeDomain( timeDomain_ )
{
}
- PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+ CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
+ memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
}
- PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+ CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
+ memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2& setPNext( const void* pNext_ )
+ CalibratedTimestampInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2& setFormat( Format format_ )
- {
- format = format_;
- return *this;
- }
-
- PhysicalDeviceSparseImageFormatInfo2& setType( ImageType type_ )
- {
- type = type_;
- return *this;
- }
-
- PhysicalDeviceSparseImageFormatInfo2& setSamples( SampleCountFlagBits samples_ )
- {
- samples = samples_;
- return *this;
- }
-
- PhysicalDeviceSparseImageFormatInfo2& setUsage( ImageUsageFlags usage_ )
+ CalibratedTimestampInfoEXT& setTimeDomain( TimeDomainEXT timeDomain_ )
{
- usage = usage_;
+ timeDomain = timeDomain_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2& setTiling( ImageTiling tiling_ )
+ operator VkCalibratedTimestampInfoEXT const&() const
{
- tiling = tiling_;
- return *this;
+ return *reinterpret_cast<const VkCalibratedTimestampInfoEXT*>(this);
}
- operator const VkPhysicalDeviceSparseImageFormatInfo2&() const
+ operator VkCalibratedTimestampInfoEXT &()
{
- return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(this);
+ return *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this);
}
- bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
+ bool operator==( CalibratedTimestampInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( format == rhs.format )
- && ( type == rhs.type )
- && ( samples == rhs.samples )
- && ( usage == rhs.usage )
- && ( tiling == rhs.tiling );
+ && ( timeDomain == rhs.timeDomain );
}
- bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
+ bool operator!=( CalibratedTimestampInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+ StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
public:
const void* pNext = nullptr;
- Format format;
- ImageType type;
- SampleCountFlagBits samples;
- ImageUsageFlags usage;
- ImageTiling tiling;
+ TimeDomainEXT timeDomain;
};
- static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
+ static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" );
- using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
+ enum class DebugReportFlagBitsEXT
+ {
+ eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
+ eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
+ ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
+ eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
+ eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
+ };
- struct SampleLocationsInfoEXT
+ using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
+
+ VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
{
- SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
- Extent2D sampleLocationGridSize_ = Extent2D(),
- uint32_t sampleLocationsCount_ = 0,
- const SampleLocationEXT* pSampleLocations_ = nullptr )
- : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
- , sampleLocationGridSize( sampleLocationGridSize_ )
- , sampleLocationsCount( sampleLocationsCount_ )
- , pSampleLocations( pSampleLocations_ )
+ return DebugReportFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
+ {
+ return ~( DebugReportFlagsEXT( bits ) );
+ }
+
+ template <> struct FlagTraits<DebugReportFlagBitsEXT>
+ {
+ enum
+ {
+ allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
+ };
+ };
+
+ struct DebugReportCallbackCreateInfoEXT
+ {
+ DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(),
+ PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
+ void* pUserData_ = nullptr )
+ : flags( flags_ )
+ , pfnCallback( pfnCallback_ )
+ , pUserData( pUserData_ )
{
}
- SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
+ DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+ memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
}
- SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
+ DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+ memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
return *this;
}
- SampleLocationsInfoEXT& setPNext( const void* pNext_ )
+ DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
+ DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
{
- sampleLocationsPerPixel = sampleLocationsPerPixel_;
+ flags = flags_;
return *this;
}
- SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
+ DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
{
- sampleLocationGridSize = sampleLocationGridSize_;
+ pfnCallback = pfnCallback_;
return *this;
}
- SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ )
+ DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
{
- sampleLocationsCount = sampleLocationsCount_;
+ pUserData = pUserData_;
return *this;
}
- SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
+ operator VkDebugReportCallbackCreateInfoEXT const&() const
{
- pSampleLocations = pSampleLocations_;
- return *this;
+ return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
}
- operator const VkSampleLocationsInfoEXT&() const
+ operator VkDebugReportCallbackCreateInfoEXT &()
{
- return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this);
+ return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this);
}
- bool operator==( SampleLocationsInfoEXT const& rhs ) const
+ bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel )
- && ( sampleLocationGridSize == rhs.sampleLocationGridSize )
- && ( sampleLocationsCount == rhs.sampleLocationsCount )
- && ( pSampleLocations == rhs.pSampleLocations );
+ && ( flags == rhs.flags )
+ && ( pfnCallback == rhs.pfnCallback )
+ && ( pUserData == rhs.pUserData );
}
- bool operator!=( SampleLocationsInfoEXT const& rhs ) const
+ bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSampleLocationsInfoEXT;
+ StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
public:
const void* pNext = nullptr;
- SampleCountFlagBits sampleLocationsPerPixel;
- Extent2D sampleLocationGridSize;
- uint32_t sampleLocationsCount;
- const SampleLocationEXT* pSampleLocations;
+ DebugReportFlagsEXT flags;
+ PFN_vkDebugReportCallbackEXT pfnCallback;
+ void* pUserData;
};
- static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
- struct AttachmentSampleLocationsEXT
+ enum class DebugReportObjectTypeEXT
{
- AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
- SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
- : attachmentIndex( attachmentIndex_ )
- , sampleLocationsInfo( sampleLocationsInfo_ )
+ eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+ eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
+ ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+ eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+ eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
+ eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+ eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+ eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
+ eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
+ eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+ eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+ eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
+ eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
+ eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
+ eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+ eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
+ ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
+ ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
+ eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+ ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+ eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
+ eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
+ eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
+ eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+ eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
+ eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
+ eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
+ eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+ eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
+ eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
+ eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
+ eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
+ eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
+ eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
+ eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+ eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+ eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+ eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+ eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+ eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+ eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT
+ };
+
+ struct DebugMarkerObjectNameInfoEXT
+ {
+ DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
+ uint64_t object_ = 0,
+ const char* pObjectName_ = nullptr )
+ : objectType( objectType_ )
+ , object( object_ )
+ , pObjectName( pObjectName_ )
{
}
- AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
+ DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
}
- AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs )
+ DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
return *this;
}
- AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ )
+ DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
{
- attachmentIndex = attachmentIndex_;
+ pNext = pNext_;
return *this;
}
- AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
{
- sampleLocationsInfo = sampleLocationsInfo_;
+ objectType = objectType_;
return *this;
}
- operator const VkAttachmentSampleLocationsEXT&() const
- {
- return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this);
- }
-
- bool operator==( AttachmentSampleLocationsEXT const& rhs ) const
- {
- return ( attachmentIndex == rhs.attachmentIndex )
- && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
- }
-
- bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- uint32_t attachmentIndex;
- SampleLocationsInfoEXT sampleLocationsInfo;
- };
- static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
-
- struct SubpassSampleLocationsEXT
- {
- SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
- SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
- : subpassIndex( subpassIndex_ )
- , sampleLocationsInfo( sampleLocationsInfo_ )
- {
- }
-
- SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
- }
-
- SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs )
+ DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
{
- memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+ object = object_;
return *this;
}
- SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ )
+
+ DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
{
- subpassIndex = subpassIndex_;
+ pObjectName = pObjectName_;
return *this;
}
- SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ operator VkDebugMarkerObjectNameInfoEXT const&() const
{
- sampleLocationsInfo = sampleLocationsInfo_;
- return *this;
+ return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
}
- operator const VkSubpassSampleLocationsEXT&() const
+ operator VkDebugMarkerObjectNameInfoEXT &()
{
- return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this);
+ return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this);
}
- bool operator==( SubpassSampleLocationsEXT const& rhs ) const
+ bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
{
- return ( subpassIndex == rhs.subpassIndex )
- && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( objectType == rhs.objectType )
+ && ( object == rhs.object )
+ && ( pObjectName == rhs.pObjectName );
}
- bool operator!=( SubpassSampleLocationsEXT const& rhs ) const
+ bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t subpassIndex;
- SampleLocationsInfoEXT sampleLocationsInfo;
+ private:
+ StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ DebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ const char* pObjectName;
};
- static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
- struct RenderPassSampleLocationsBeginInfoEXT
+ struct DebugMarkerObjectTagInfoEXT
{
- RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
- const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
- uint32_t postSubpassSampleLocationsCount_ = 0,
- const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
- : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
- , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
- , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
- , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+ DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
+ uint64_t object_ = 0,
+ uint64_t tagName_ = 0,
+ size_t tagSize_ = 0,
+ const void* pTag_ = nullptr )
+ : objectType( objectType_ )
+ , object( object_ )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
{
}
- RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+ DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
}
- RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+ DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ )
+ DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ )
+ DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
{
- attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
+ objectType = objectType_;
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
+ DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
{
- pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
+ object = object_;
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ )
+ DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
{
- postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
+ tagName = tagName_;
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
+ DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
{
- pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
+ tagSize = tagSize_;
return *this;
}
- operator const VkRenderPassSampleLocationsBeginInfoEXT&() const
+ DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
{
- return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this);
+ pTag = pTag_;
+ return *this;
}
- bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+ operator VkDebugMarkerObjectTagInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
+ }
+
+ operator VkDebugMarkerObjectTagInfoEXT &()
+ {
+ return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this);
+ }
+
+ bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount )
- && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations )
- && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount )
- && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+ && ( objectType == rhs.objectType )
+ && ( object == rhs.object )
+ && ( tagName == rhs.tagName )
+ && ( tagSize == rhs.tagSize )
+ && ( pTag == rhs.pTag );
}
- bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+ bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+ StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
public:
const void* pNext = nullptr;
- uint32_t attachmentInitialSampleLocationsCount;
- const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
- uint32_t postSubpassSampleLocationsCount;
- const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+ DebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
};
- static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
- struct PipelineSampleLocationsStateCreateInfoEXT
+ enum class RasterizationOrderAMD
{
- PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0,
- SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
- : sampleLocationsEnable( sampleLocationsEnable_ )
- , sampleLocationsInfo( sampleLocationsInfo_ )
+ eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
+ eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
+ };
+
+ struct PipelineRasterizationStateRasterizationOrderAMD
+ {
+ PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
+ : rasterizationOrder( rasterizationOrder_ )
{
}
- PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+ PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
}
- PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+ PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
return *this;
}
- PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ )
+ PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
- {
- sampleLocationsEnable = sampleLocationsEnable_;
- return *this;
- }
-
- PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
{
- sampleLocationsInfo = sampleLocationsInfo_;
+ rasterizationOrder = rasterizationOrder_;
return *this;
}
- operator const VkPipelineSampleLocationsStateCreateInfoEXT&() const
- {
- return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
- }
-
- bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( sampleLocationsEnable == rhs.sampleLocationsEnable )
- && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
- }
-
- bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+ operator VkPipelineRasterizationStateRasterizationOrderAMD const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
}
- private:
- StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Bool32 sampleLocationsEnable;
- SampleLocationsInfoEXT sampleLocationsInfo;
- };
- static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
- struct PhysicalDeviceSampleLocationsPropertiesEXT
- {
- operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const
+ operator VkPipelineRasterizationStateRasterizationOrderAMD &()
{
- return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+ return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
}
- bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
+ bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts )
- && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize )
- && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 )
- && ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits )
- && ( variableSampleLocations == rhs.variableSampleLocations );
+ && ( rasterizationOrder == rhs.rasterizationOrder );
}
- bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
+ bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
{
return !operator==( rhs );
}
-
- private:
- StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- SampleCountFlags sampleLocationSampleCounts;
- Extent2D maxSampleLocationGridSize;
- float sampleLocationCoordinateRange[2];
- uint32_t sampleLocationSubPixelBits;
- Bool32 variableSampleLocations;
+
+ private:
+ StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+
+ public:
+ const void* pNext = nullptr;
+ RasterizationOrderAMD rasterizationOrder;
};
- static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
- enum class AttachmentDescriptionFlagBits
+ enum class ExternalMemoryHandleTypeFlagBitsNV
{
- eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+ eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
+ eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
+ eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
+ eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
};
- using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
+ using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
- VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
{
- return AttachmentDescriptionFlags( bit0 ) | bit1;
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
{
- return ~( AttachmentDescriptionFlags( bits ) );
+ return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
}
- template <> struct FlagTraits<AttachmentDescriptionFlagBits>
+ template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
{
enum
{
- allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
+ allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
};
};
- struct AttachmentDescription
+ struct ExternalMemoryImageCreateInfoNV
{
- AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
- Format format_ = Format::eUndefined,
- SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
- AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
- AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
- AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
- AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
- ImageLayout initialLayout_ = ImageLayout::eUndefined,
- ImageLayout finalLayout_ = ImageLayout::eUndefined )
- : flags( flags_ )
- , format( format_ )
- , samples( samples_ )
- , loadOp( loadOp_ )
- , storeOp( storeOp_ )
- , stencilLoadOp( stencilLoadOp_ )
- , stencilStoreOp( stencilStoreOp_ )
- , initialLayout( initialLayout_ )
- , finalLayout( finalLayout_ )
+ ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
+ : handleTypes( handleTypes_ )
{
}
- AttachmentDescription( VkAttachmentDescription const & rhs )
+ ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentDescription ) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
}
- AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
+ ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentDescription ) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
return *this;
}
- AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
+ ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
{
- flags = flags_;
+ pNext = pNext_;
return *this;
}
- AttachmentDescription& setFormat( Format format_ )
+ ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
{
- format = format_;
+ handleTypes = handleTypes_;
return *this;
}
- AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
+ operator VkExternalMemoryImageCreateInfoNV const&() const
{
- samples = samples_;
- return *this;
+ return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
}
- AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
+ operator VkExternalMemoryImageCreateInfoNV &()
{
- loadOp = loadOp_;
- return *this;
+ return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this);
}
- AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
+ bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
{
- storeOp = storeOp_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleTypes == rhs.handleTypes );
}
- AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
{
- stencilLoadOp = stencilLoadOp_;
- return *this;
+ return !operator==( rhs );
}
- AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ private:
+ StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
+
+ public:
+ const void* pNext = nullptr;
+ ExternalMemoryHandleTypeFlagsNV handleTypes;
+ };
+ static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
+
+ struct ExportMemoryAllocateInfoNV
+ {
+ ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
+ : handleTypes( handleTypes_ )
{
- stencilStoreOp = stencilStoreOp_;
- return *this;
}
- AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
+ ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
{
- initialLayout = initialLayout_;
- return *this;
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
}
- AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
+ ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
{
- finalLayout = finalLayout_;
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
return *this;
}
-
- operator const VkAttachmentDescription&() const
+ ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
{
- return *reinterpret_cast<const VkAttachmentDescription*>(this);
+ pNext = pNext_;
+ return *this;
}
- bool operator==( AttachmentDescription const& rhs ) const
+ ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
{
- return ( flags == rhs.flags )
- && ( format == rhs.format )
- && ( samples == rhs.samples )
- && ( loadOp == rhs.loadOp )
- && ( storeOp == rhs.storeOp )
- && ( stencilLoadOp == rhs.stencilLoadOp )
- && ( stencilStoreOp == rhs.stencilStoreOp )
- && ( initialLayout == rhs.initialLayout )
- && ( finalLayout == rhs.finalLayout );
+ handleTypes = handleTypes_;
+ return *this;
}
- bool operator!=( AttachmentDescription const& rhs ) const
+ operator VkExportMemoryAllocateInfoNV const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
}
- AttachmentDescriptionFlags flags;
- Format format;
- SampleCountFlagBits samples;
- AttachmentLoadOp loadOp;
- AttachmentStoreOp storeOp;
- AttachmentLoadOp stencilLoadOp;
- AttachmentStoreOp stencilStoreOp;
- ImageLayout initialLayout;
- ImageLayout finalLayout;
- };
- static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
-
- struct AttachmentDescription2KHR
- {
- AttachmentDescription2KHR( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
- Format format_ = Format::eUndefined,
- SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
- AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
- AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
- AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
- AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
- ImageLayout initialLayout_ = ImageLayout::eUndefined,
- ImageLayout finalLayout_ = ImageLayout::eUndefined )
- : flags( flags_ )
- , format( format_ )
- , samples( samples_ )
- , loadOp( loadOp_ )
- , storeOp( storeOp_ )
- , stencilLoadOp( stencilLoadOp_ )
- , stencilStoreOp( stencilStoreOp_ )
- , initialLayout( initialLayout_ )
- , finalLayout( finalLayout_ )
+ operator VkExportMemoryAllocateInfoNV &()
{
+ return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this);
}
- AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
+ bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
{
- memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleTypes == rhs.handleTypes );
}
- AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
- return *this;
- }
- AttachmentDescription2KHR& setPNext( const void* pNext_ )
+ bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
{
- pNext = pNext_;
- return *this;
+ return !operator==( rhs );
}
- AttachmentDescription2KHR& setFlags( AttachmentDescriptionFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
+ private:
+ StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
- AttachmentDescription2KHR& setFormat( Format format_ )
- {
- format = format_;
- return *this;
- }
+ public:
+ const void* pNext = nullptr;
+ ExternalMemoryHandleTypeFlagsNV handleTypes;
+ };
+ static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
- AttachmentDescription2KHR& setSamples( SampleCountFlagBits samples_ )
+#ifdef VK_USE_PLATFORM_WIN32_NV
+ struct ImportMemoryWin32HandleInfoNV
+ {
+ ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
+ HANDLE handle_ = 0 )
+ : handleType( handleType_ )
+ , handle( handle_ )
{
- samples = samples_;
- return *this;
}
- AttachmentDescription2KHR& setLoadOp( AttachmentLoadOp loadOp_ )
+ ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
{
- loadOp = loadOp_;
- return *this;
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
}
- AttachmentDescription2KHR& setStoreOp( AttachmentStoreOp storeOp_ )
+ ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
{
- storeOp = storeOp_;
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
return *this;
}
-
- AttachmentDescription2KHR& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
{
- stencilLoadOp = stencilLoadOp_;
+ pNext = pNext_;
return *this;
}
- AttachmentDescription2KHR& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
{
- stencilStoreOp = stencilStoreOp_;
+ handleType = handleType_;
return *this;
}
- AttachmentDescription2KHR& setInitialLayout( ImageLayout initialLayout_ )
+ ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
{
- initialLayout = initialLayout_;
+ handle = handle_;
return *this;
}
- AttachmentDescription2KHR& setFinalLayout( ImageLayout finalLayout_ )
+ operator VkImportMemoryWin32HandleInfoNV const&() const
{
- finalLayout = finalLayout_;
- return *this;
+ return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
}
- operator const VkAttachmentDescription2KHR&() const
+ operator VkImportMemoryWin32HandleInfoNV &()
{
- return *reinterpret_cast<const VkAttachmentDescription2KHR*>(this);
+ return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this);
}
- bool operator==( AttachmentDescription2KHR const& rhs ) const
+ bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( format == rhs.format )
- && ( samples == rhs.samples )
- && ( loadOp == rhs.loadOp )
- && ( storeOp == rhs.storeOp )
- && ( stencilLoadOp == rhs.stencilLoadOp )
- && ( stencilStoreOp == rhs.stencilStoreOp )
- && ( initialLayout == rhs.initialLayout )
- && ( finalLayout == rhs.finalLayout );
+ && ( handleType == rhs.handleType )
+ && ( handle == rhs.handle );
}
- bool operator!=( AttachmentDescription2KHR const& rhs ) const
+ bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eAttachmentDescription2KHR;
+ StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
public:
const void* pNext = nullptr;
- AttachmentDescriptionFlags flags;
- Format format;
- SampleCountFlagBits samples;
- AttachmentLoadOp loadOp;
- AttachmentStoreOp storeOp;
- AttachmentLoadOp stencilLoadOp;
- AttachmentStoreOp stencilStoreOp;
- ImageLayout initialLayout;
- ImageLayout finalLayout;
+ ExternalMemoryHandleTypeFlagsNV handleType;
+ HANDLE handle;
};
- static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_NV*/
- enum class StencilFaceFlagBits
+ enum class ExternalMemoryFeatureFlagBitsNV
{
- eFront = VK_STENCIL_FACE_FRONT_BIT,
- eBack = VK_STENCIL_FACE_BACK_BIT,
- eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
+ eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
+ eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
+ eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
};
- using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
+ using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
- VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
{
- return StencilFaceFlags( bit0 ) | bit1;
+ return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
{
- return ~( StencilFaceFlags( bits ) );
+ return ~( ExternalMemoryFeatureFlagsNV( bits ) );
}
- template <> struct FlagTraits<StencilFaceFlagBits>
+ template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
{
enum
{
- allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
+ allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
};
};
- enum class DescriptorPoolCreateFlagBits
+ struct ExternalImageFormatPropertiesNV
{
- eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
- eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
- };
+ operator VkExternalImageFormatPropertiesNV const&() const
+ {
+ return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
+ }
- using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
+ operator VkExternalImageFormatPropertiesNV &()
+ {
+ return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this);
+ }
- VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
- {
- return DescriptorPoolCreateFlags( bit0 ) | bit1;
- }
+ bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
+ {
+ return ( imageFormatProperties == rhs.imageFormatProperties )
+ && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+ }
- VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
- {
- return ~( DescriptorPoolCreateFlags( bits ) );
- }
+ bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
+ ImageFormatProperties imageFormatProperties;
+ ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
+ ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
+ ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
+ };
+ static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
+
+ enum class ValidationCheckEXT
{
- enum
- {
- allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT)
- };
+ eAll = VK_VALIDATION_CHECK_ALL_EXT,
+ eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
};
- struct DescriptorPoolCreateInfo
+ struct ValidationFlagsEXT
{
- DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(),
- uint32_t maxSets_ = 0,
- uint32_t poolSizeCount_ = 0,
- const DescriptorPoolSize* pPoolSizes_ = nullptr )
- : flags( flags_ )
- , maxSets( maxSets_ )
- , poolSizeCount( poolSizeCount_ )
- , pPoolSizes( pPoolSizes_ )
+ ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
+ const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+ : disabledValidationCheckCount( disabledValidationCheckCount_ )
+ , pDisabledValidationChecks( pDisabledValidationChecks_ )
{
}
- DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+ ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
}
- DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+ ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
return *this;
}
- DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
+ ValidationFlagsEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
+ ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
{
- maxSets = maxSets_;
+ disabledValidationCheckCount = disabledValidationCheckCount_;
return *this;
}
- DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
+ ValidationFlagsEXT& setPDisabledValidationChecks( const ValidationCheckEXT* pDisabledValidationChecks_ )
{
- poolSizeCount = poolSizeCount_;
+ pDisabledValidationChecks = pDisabledValidationChecks_;
return *this;
}
- DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
+ operator VkValidationFlagsEXT const&() const
{
- pPoolSizes = pPoolSizes_;
- return *this;
+ return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
}
- operator const VkDescriptorPoolCreateInfo&() const
+ operator VkValidationFlagsEXT &()
{
- return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
+ return *reinterpret_cast<VkValidationFlagsEXT*>(this);
}
- bool operator==( DescriptorPoolCreateInfo const& rhs ) const
+ bool operator==( ValidationFlagsEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( maxSets == rhs.maxSets )
- && ( poolSizeCount == rhs.poolSizeCount )
- && ( pPoolSizes == rhs.pPoolSizes );
+ && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
+ && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
}
- bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
+ bool operator!=( ValidationFlagsEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDescriptorPoolCreateInfo;
+ StructureType sType = StructureType::eValidationFlagsEXT;
public:
const void* pNext = nullptr;
- DescriptorPoolCreateFlags flags;
- uint32_t maxSets;
- uint32_t poolSizeCount;
- const DescriptorPoolSize* pPoolSizes;
+ uint32_t disabledValidationCheckCount;
+ const ValidationCheckEXT* pDisabledValidationChecks;
};
- static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
- enum class DependencyFlagBits
+ enum class SubgroupFeatureFlagBits
{
- eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
- eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT,
- eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
- eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT,
- eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT
+ eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT,
+ eVote = VK_SUBGROUP_FEATURE_VOTE_BIT,
+ eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT,
+ eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT,
+ eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT,
+ eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT,
+ eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT,
+ eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT,
+ ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
};
- using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
+ using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits, VkSubgroupFeatureFlags>;
- VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
{
- return DependencyFlags( bit0 ) | bit1;
+ return SubgroupFeatureFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
+ VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits )
{
- return ~( DependencyFlags( bits ) );
+ return ~( SubgroupFeatureFlags( bits ) );
}
- template <> struct FlagTraits<DependencyFlagBits>
+ template <> struct FlagTraits<SubgroupFeatureFlagBits>
{
enum
{
- allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eDeviceGroup) | VkFlags(DependencyFlagBits::eViewLocal)
+ allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) | VkFlags(SubgroupFeatureFlagBits::eVote) | VkFlags(SubgroupFeatureFlagBits::eArithmetic) | VkFlags(SubgroupFeatureFlagBits::eBallot) | VkFlags(SubgroupFeatureFlagBits::eShuffle) | VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) | VkFlags(SubgroupFeatureFlagBits::eClustered) | VkFlags(SubgroupFeatureFlagBits::eQuad) | VkFlags(SubgroupFeatureFlagBits::ePartitionedNV)
};
};
- struct SubpassDependency
+ struct PhysicalDeviceSubgroupProperties
{
- SubpassDependency( uint32_t srcSubpass_ = 0,
- uint32_t dstSubpass_ = 0,
- PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
- PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
- AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- DependencyFlags dependencyFlags_ = DependencyFlags() )
- : srcSubpass( srcSubpass_ )
- , dstSubpass( dstSubpass_ )
- , srcStageMask( srcStageMask_ )
- , dstStageMask( dstStageMask_ )
- , srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , dependencyFlags( dependencyFlags_ )
+ operator VkPhysicalDeviceSubgroupProperties const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(this);
+ }
+
+ operator VkPhysicalDeviceSubgroupProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this);
+ }
+
+ bool operator==( PhysicalDeviceSubgroupProperties const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( subgroupSize == rhs.subgroupSize )
+ && ( supportedStages == rhs.supportedStages )
+ && ( supportedOperations == rhs.supportedOperations )
+ && ( quadOperationsInAllStages == rhs.quadOperationsInAllStages );
+ }
+
+ bool operator!=( PhysicalDeviceSubgroupProperties const& rhs ) const
{
+ return !operator==( rhs );
}
- SubpassDependency( VkSubpassDependency const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassDependency ) );
- }
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
+
+ public:
+ void* pNext = nullptr;
+ uint32_t subgroupSize;
+ ShaderStageFlags supportedStages;
+ SubgroupFeatureFlags supportedOperations;
+ Bool32 quadOperationsInAllStages;
+ };
+ static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" );
+
+ enum class IndirectCommandsLayoutUsageFlagBitsNVX
+ {
+ eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
+ eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
+ eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
+ eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
+ };
+
+ using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
+
+ VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
+ {
+ return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
+ }
+
+ template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
+ {
+ enum
+ {
+ allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
+ };
+ };
+
+ enum class ObjectEntryUsageFlagBitsNVX
+ {
+ eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
+ eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
+ };
+
+ using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
+
+ VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
+ {
+ return ~( ObjectEntryUsageFlagsNVX( bits ) );
+ }
- SubpassDependency& operator=( VkSubpassDependency const & rhs )
+ template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
+ {
+ enum
{
- memcpy( this, &rhs, sizeof( SubpassDependency ) );
- return *this;
- }
- SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
+ allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
+ };
+ };
+
+ enum class IndirectCommandsTokenTypeNVX
+ {
+ ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
+ eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
+ eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
+ eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
+ ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
+ eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
+ eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
+ eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
+ };
+
+ struct IndirectCommandsTokenNVX
+ {
+ IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
+ Buffer buffer_ = Buffer(),
+ DeviceSize offset_ = 0 )
+ : tokenType( tokenType_ )
+ , buffer( buffer_ )
+ , offset( offset_ )
{
- srcSubpass = srcSubpass_;
- return *this;
}
- SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
+ IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
{
- dstSubpass = dstSubpass_;
- return *this;
+ memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
}
- SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
{
- srcStageMask = srcStageMask_;
+ memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
return *this;
}
-
- SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
+ IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
{
- dstStageMask = dstStageMask_;
+ tokenType = tokenType_;
return *this;
}
- SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ )
{
- srcAccessMask = srcAccessMask_;
+ buffer = buffer_;
return *this;
}
- SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
+ IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ )
{
- dstAccessMask = dstAccessMask_;
+ offset = offset_;
return *this;
}
- SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
+ operator VkIndirectCommandsTokenNVX const&() const
{
- dependencyFlags = dependencyFlags_;
- return *this;
+ return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
}
- operator const VkSubpassDependency&() const
+ operator VkIndirectCommandsTokenNVX &()
{
- return *reinterpret_cast<const VkSubpassDependency*>(this);
+ return *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this);
}
- bool operator==( SubpassDependency const& rhs ) const
+ bool operator==( IndirectCommandsTokenNVX const& rhs ) const
{
- return ( srcSubpass == rhs.srcSubpass )
- && ( dstSubpass == rhs.dstSubpass )
- && ( srcStageMask == rhs.srcStageMask )
- && ( dstStageMask == rhs.dstStageMask )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( dependencyFlags == rhs.dependencyFlags );
+ return ( tokenType == rhs.tokenType )
+ && ( buffer == rhs.buffer )
+ && ( offset == rhs.offset );
}
- bool operator!=( SubpassDependency const& rhs ) const
+ bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
{
return !operator==( rhs );
}
- uint32_t srcSubpass;
- uint32_t dstSubpass;
- PipelineStageFlags srcStageMask;
- PipelineStageFlags dstStageMask;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- DependencyFlags dependencyFlags;
+ IndirectCommandsTokenTypeNVX tokenType;
+ Buffer buffer;
+ DeviceSize offset;
};
- static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
+ static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
- struct SubpassDependency2KHR
+ struct IndirectCommandsLayoutTokenNVX
{
- SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
- uint32_t dstSubpass_ = 0,
- PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
- PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
- AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- DependencyFlags dependencyFlags_ = DependencyFlags(),
- int32_t viewOffset_ = 0 )
- : srcSubpass( srcSubpass_ )
- , dstSubpass( dstSubpass_ )
- , srcStageMask( srcStageMask_ )
- , dstStageMask( dstStageMask_ )
- , srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , dependencyFlags( dependencyFlags_ )
- , viewOffset( viewOffset_ )
- {
- }
-
- SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
- }
-
- SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
- return *this;
- }
- SubpassDependency2KHR& setPNext( const void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
-
- SubpassDependency2KHR& setSrcSubpass( uint32_t srcSubpass_ )
+ IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
+ uint32_t bindingUnit_ = 0,
+ uint32_t dynamicCount_ = 0,
+ uint32_t divisor_ = 0 )
+ : tokenType( tokenType_ )
+ , bindingUnit( bindingUnit_ )
+ , dynamicCount( dynamicCount_ )
+ , divisor( divisor_ )
{
- srcSubpass = srcSubpass_;
- return *this;
}
- SubpassDependency2KHR& setDstSubpass( uint32_t dstSubpass_ )
+ IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- dstSubpass = dstSubpass_;
- return *this;
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
}
- SubpassDependency2KHR& setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- srcStageMask = srcStageMask_;
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
return *this;
}
-
- SubpassDependency2KHR& setDstStageMask( PipelineStageFlags dstStageMask_ )
+ IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
{
- dstStageMask = dstStageMask_;
+ tokenType = tokenType_;
return *this;
}
- SubpassDependency2KHR& setSrcAccessMask( AccessFlags srcAccessMask_ )
+ IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ )
{
- srcAccessMask = srcAccessMask_;
+ bindingUnit = bindingUnit_;
return *this;
}
- SubpassDependency2KHR& setDstAccessMask( AccessFlags dstAccessMask_ )
+ IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ )
{
- dstAccessMask = dstAccessMask_;
+ dynamicCount = dynamicCount_;
return *this;
}
- SubpassDependency2KHR& setDependencyFlags( DependencyFlags dependencyFlags_ )
+ IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ )
{
- dependencyFlags = dependencyFlags_;
+ divisor = divisor_;
return *this;
}
- SubpassDependency2KHR& setViewOffset( int32_t viewOffset_ )
+ operator VkIndirectCommandsLayoutTokenNVX const&() const
{
- viewOffset = viewOffset_;
- return *this;
+ return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
}
- operator const VkSubpassDependency2KHR&() const
+ operator VkIndirectCommandsLayoutTokenNVX &()
{
- return *reinterpret_cast<const VkSubpassDependency2KHR*>(this);
+ return *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this);
}
- bool operator==( SubpassDependency2KHR const& rhs ) const
+ bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( srcSubpass == rhs.srcSubpass )
- && ( dstSubpass == rhs.dstSubpass )
- && ( srcStageMask == rhs.srcStageMask )
- && ( dstStageMask == rhs.dstStageMask )
- && ( srcAccessMask == rhs.srcAccessMask )
- && ( dstAccessMask == rhs.dstAccessMask )
- && ( dependencyFlags == rhs.dependencyFlags )
- && ( viewOffset == rhs.viewOffset );
+ return ( tokenType == rhs.tokenType )
+ && ( bindingUnit == rhs.bindingUnit )
+ && ( dynamicCount == rhs.dynamicCount )
+ && ( divisor == rhs.divisor );
}
- bool operator!=( SubpassDependency2KHR const& rhs ) const
+ bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType = StructureType::eSubpassDependency2KHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t srcSubpass;
- uint32_t dstSubpass;
- PipelineStageFlags srcStageMask;
- PipelineStageFlags dstStageMask;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- DependencyFlags dependencyFlags;
- int32_t viewOffset;
- };
- static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
-
- enum class PresentModeKHR
- {
- eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
- eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
- eFifo = VK_PRESENT_MODE_FIFO_KHR,
- eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
- eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
- eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
- };
-
- enum class ColorSpaceKHR
- {
- eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
- eVkColorspaceSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
- eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
- eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
- eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
- eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
- eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
- eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
- eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
- eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
- eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
- eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
- eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
- eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
- ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
- eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT
+ IndirectCommandsTokenTypeNVX tokenType;
+ uint32_t bindingUnit;
+ uint32_t dynamicCount;
+ uint32_t divisor;
};
+ static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
- struct SurfaceFormatKHR
+ struct IndirectCommandsLayoutCreateInfoNVX
{
- operator const VkSurfaceFormatKHR&() const
+ IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+ IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(),
+ uint32_t tokenCount_ = 0,
+ const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+ : pipelineBindPoint( pipelineBindPoint_ )
+ , flags( flags_ )
+ , tokenCount( tokenCount_ )
+ , pTokens( pTokens_ )
{
- return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
}
- bool operator==( SurfaceFormatKHR const& rhs ) const
+ IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- return ( format == rhs.format )
- && ( colorSpace == rhs.colorSpace );
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
}
- bool operator!=( SurfaceFormatKHR const& rhs ) const
+ IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
+ return *this;
}
-
- Format format;
- ColorSpaceKHR colorSpace;
- };
- static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
-
- struct SurfaceFormat2KHR
- {
- operator const VkSurfaceFormat2KHR&() const
+ IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
{
- return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
+ pNext = pNext_;
+ return *this;
}
- bool operator==( SurfaceFormat2KHR const& rhs ) const
+ IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( surfaceFormat == rhs.surfaceFormat );
+ pipelineBindPoint = pipelineBindPoint_;
+ return *this;
}
- bool operator!=( SurfaceFormat2KHR const& rhs ) const
+ IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
{
- return !operator==( rhs );
+ flags = flags_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eSurfaceFormat2KHR;
-
- public:
- void* pNext = nullptr;
- SurfaceFormatKHR surfaceFormat;
- };
- static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
-
- enum class DisplayPlaneAlphaFlagBitsKHR
- {
- eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
- eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
- ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
- ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
- };
-
- using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
-
- VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
- {
- return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
- {
- return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
- }
-
- template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
- {
- enum
- {
- allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
- };
- };
-
- struct DisplayPlaneCapabilitiesKHR
- {
- operator const VkDisplayPlaneCapabilitiesKHR&() const
+ IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ )
{
- return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
+ tokenCount = tokenCount_;
+ return *this;
}
- bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
{
- return ( supportedAlpha == rhs.supportedAlpha )
- && ( minSrcPosition == rhs.minSrcPosition )
- && ( maxSrcPosition == rhs.maxSrcPosition )
- && ( minSrcExtent == rhs.minSrcExtent )
- && ( maxSrcExtent == rhs.maxSrcExtent )
- && ( minDstPosition == rhs.minDstPosition )
- && ( maxDstPosition == rhs.maxDstPosition )
- && ( minDstExtent == rhs.minDstExtent )
- && ( maxDstExtent == rhs.maxDstExtent );
+ pTokens = pTokens_;
+ return *this;
}
- bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
+ operator VkIndirectCommandsLayoutCreateInfoNVX const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
}
- DisplayPlaneAlphaFlagsKHR supportedAlpha;
- Offset2D minSrcPosition;
- Offset2D maxSrcPosition;
- Extent2D minSrcExtent;
- Extent2D maxSrcExtent;
- Offset2D minDstPosition;
- Offset2D maxDstPosition;
- Extent2D minDstExtent;
- Extent2D maxDstExtent;
- };
- static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
-
- struct DisplayPlaneCapabilities2KHR
- {
- operator const VkDisplayPlaneCapabilities2KHR&() const
+ operator VkIndirectCommandsLayoutCreateInfoNVX &()
{
- return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(this);
+ return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this);
}
- bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const
+ bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( capabilities == rhs.capabilities );
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( flags == rhs.flags )
+ && ( tokenCount == rhs.tokenCount )
+ && ( pTokens == rhs.pTokens );
}
- bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const
+ bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
+ StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
public:
- void* pNext = nullptr;
- DisplayPlaneCapabilitiesKHR capabilities;
- };
- static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
-
- enum class CompositeAlphaFlagBitsKHR
- {
- eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
- ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
- ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
- eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
- };
-
- using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
-
- VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
- {
- return CompositeAlphaFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
- {
- return ~( CompositeAlphaFlagsKHR( bits ) );
- }
-
- template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
- {
- enum
- {
- allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
- };
- };
-
- enum class SurfaceTransformFlagBitsKHR
- {
- eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
- eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
- eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
- eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
- eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
- eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
- eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
- eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
- eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
- };
-
- using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
-
- VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
- {
- return SurfaceTransformFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
- {
- return ~( SurfaceTransformFlagsKHR( bits ) );
- }
-
- template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
- {
- enum
- {
- allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
- };
+ const void* pNext = nullptr;
+ PipelineBindPoint pipelineBindPoint;
+ IndirectCommandsLayoutUsageFlagsNVX flags;
+ uint32_t tokenCount;
+ const IndirectCommandsLayoutTokenNVX* pTokens;
};
+ static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
- struct DisplayPropertiesKHR
+ enum class ObjectEntryTypeNVX
{
- operator const VkDisplayPropertiesKHR&() const
- {
- return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
- }
-
- bool operator==( DisplayPropertiesKHR const& rhs ) const
- {
- return ( display == rhs.display )
- && ( displayName == rhs.displayName )
- && ( physicalDimensions == rhs.physicalDimensions )
- && ( physicalResolution == rhs.physicalResolution )
- && ( supportedTransforms == rhs.supportedTransforms )
- && ( planeReorderPossible == rhs.planeReorderPossible )
- && ( persistentContent == rhs.persistentContent );
- }
-
- bool operator!=( DisplayPropertiesKHR const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- DisplayKHR display;
- const char* displayName;
- Extent2D physicalDimensions;
- Extent2D physicalResolution;
- SurfaceTransformFlagsKHR supportedTransforms;
- Bool32 planeReorderPossible;
- Bool32 persistentContent;
+ eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
+ ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX,
+ eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX,
+ eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX,
+ ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
};
- static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
- struct DisplaySurfaceCreateInfoKHR
+ struct ObjectTableCreateInfoNVX
{
- DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(),
- DisplayModeKHR displayMode_ = DisplayModeKHR(),
- uint32_t planeIndex_ = 0,
- uint32_t planeStackIndex_ = 0,
- SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity,
- float globalAlpha_ = 0,
- DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque,
- Extent2D imageExtent_ = Extent2D() )
- : flags( flags_ )
- , displayMode( displayMode_ )
- , planeIndex( planeIndex_ )
- , planeStackIndex( planeStackIndex_ )
- , transform( transform_ )
- , globalAlpha( globalAlpha_ )
- , alphaMode( alphaMode_ )
- , imageExtent( imageExtent_ )
+ ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
+ const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
+ const uint32_t* pObjectEntryCounts_ = nullptr,
+ const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
+ uint32_t maxUniformBuffersPerDescriptor_ = 0,
+ uint32_t maxStorageBuffersPerDescriptor_ = 0,
+ uint32_t maxStorageImagesPerDescriptor_ = 0,
+ uint32_t maxSampledImagesPerDescriptor_ = 0,
+ uint32_t maxPipelineLayouts_ = 0 )
+ : objectCount( objectCount_ )
+ , pObjectEntryTypes( pObjectEntryTypes_ )
+ , pObjectEntryCounts( pObjectEntryCounts_ )
+ , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
+ , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
+ , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
+ , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
+ , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
+ , maxPipelineLayouts( maxPipelineLayouts_ )
{
}
- DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+ memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
}
- DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+ memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
return *this;
}
- DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
+ ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
+ ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ )
{
- flags = flags_;
+ objectCount = objectCount_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
+ ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
{
- displayMode = displayMode_;
+ pObjectEntryTypes = pObjectEntryTypes_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
+ ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
{
- planeIndex = planeIndex_;
+ pObjectEntryCounts = pObjectEntryCounts_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
+ ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
{
- planeStackIndex = planeStackIndex_;
+ pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
+ ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
{
- transform = transform_;
+ maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
+ ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
{
- globalAlpha = globalAlpha_;
+ maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
+ ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
{
- alphaMode = alphaMode_;
+ maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
return *this;
}
- DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
{
- imageExtent = imageExtent_;
+ maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
return *this;
}
- operator const VkDisplaySurfaceCreateInfoKHR&() const
+ ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
{
- return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
+ maxPipelineLayouts = maxPipelineLayouts_;
+ return *this;
}
- bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
+ operator VkObjectTableCreateInfoNVX const&() const
+ {
+ return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
+ }
+
+ operator VkObjectTableCreateInfoNVX &()
+ {
+ return *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this);
+ }
+
+ bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( displayMode == rhs.displayMode )
- && ( planeIndex == rhs.planeIndex )
- && ( planeStackIndex == rhs.planeStackIndex )
- && ( transform == rhs.transform )
- && ( globalAlpha == rhs.globalAlpha )
- && ( alphaMode == rhs.alphaMode )
- && ( imageExtent == rhs.imageExtent );
+ && ( objectCount == rhs.objectCount )
+ && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
+ && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
+ && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
+ && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
+ && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
+ && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
+ && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
+ && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
}
- bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
+ bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
+ StructureType sType = StructureType::eObjectTableCreateInfoNVX;
public:
const void* pNext = nullptr;
- DisplaySurfaceCreateFlagsKHR flags;
- DisplayModeKHR displayMode;
- uint32_t planeIndex;
- uint32_t planeStackIndex;
- SurfaceTransformFlagBitsKHR transform;
- float globalAlpha;
- DisplayPlaneAlphaFlagBitsKHR alphaMode;
- Extent2D imageExtent;
+ uint32_t objectCount;
+ const ObjectEntryTypeNVX* pObjectEntryTypes;
+ const uint32_t* pObjectEntryCounts;
+ const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
+ uint32_t maxUniformBuffersPerDescriptor;
+ uint32_t maxStorageBuffersPerDescriptor;
+ uint32_t maxStorageImagesPerDescriptor;
+ uint32_t maxSampledImagesPerDescriptor;
+ uint32_t maxPipelineLayouts;
};
- static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
- struct SurfaceCapabilitiesKHR
+ struct ObjectTableEntryNVX
{
- operator const VkSurfaceCapabilitiesKHR&() const
+ ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+ ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
+ : type( type_ )
+ , flags( flags_ )
{
- return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
}
- bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
+ ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
{
- return ( minImageCount == rhs.minImageCount )
- && ( maxImageCount == rhs.maxImageCount )
- && ( currentExtent == rhs.currentExtent )
- && ( minImageExtent == rhs.minImageExtent )
- && ( maxImageExtent == rhs.maxImageExtent )
- && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
- && ( supportedTransforms == rhs.supportedTransforms )
- && ( currentTransform == rhs.currentTransform )
- && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
- && ( supportedUsageFlags == rhs.supportedUsageFlags );
+ memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
}
- bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
+ ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
+ return *this;
+ }
+ ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ {
+ type = type_;
+ return *this;
}
- uint32_t minImageCount;
- uint32_t maxImageCount;
- Extent2D currentExtent;
- Extent2D minImageExtent;
- Extent2D maxImageExtent;
- uint32_t maxImageArrayLayers;
- SurfaceTransformFlagsKHR supportedTransforms;
- SurfaceTransformFlagBitsKHR currentTransform;
- CompositeAlphaFlagsKHR supportedCompositeAlpha;
- ImageUsageFlags supportedUsageFlags;
- };
- static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+ ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
- struct SurfaceCapabilities2KHR
- {
- operator const VkSurfaceCapabilities2KHR&() const
+ operator VkObjectTableEntryNVX const&() const
{
- return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
+ return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
}
- bool operator==( SurfaceCapabilities2KHR const& rhs ) const
+ operator VkObjectTableEntryNVX &()
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( surfaceCapabilities == rhs.surfaceCapabilities );
+ return *reinterpret_cast<VkObjectTableEntryNVX*>(this);
}
- bool operator!=( SurfaceCapabilities2KHR const& rhs ) const
+ bool operator==( ObjectTableEntryNVX const& rhs ) const
{
- return !operator==( rhs );
+ return ( type == rhs.type )
+ && ( flags == rhs.flags );
}
- private:
- StructureType sType = StructureType::eSurfaceCapabilities2KHR;
+ bool operator!=( ObjectTableEntryNVX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- public:
- void* pNext = nullptr;
- SurfaceCapabilitiesKHR surfaceCapabilities;
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
};
- static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
- struct DisplayProperties2KHR
+ struct ObjectTablePipelineEntryNVX
{
- operator const VkDisplayProperties2KHR&() const
+ ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+ ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+ Pipeline pipeline_ = Pipeline() )
+ : type( type_ )
+ , flags( flags_ )
+ , pipeline( pipeline_ )
{
- return *reinterpret_cast<const VkDisplayProperties2KHR*>(this);
}
- bool operator==( DisplayProperties2KHR const& rhs ) const
+ explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+ Pipeline pipeline_ = Pipeline() )
+ : type( objectTableEntryNVX.type )
+ , flags( objectTableEntryNVX.flags )
+ , pipeline( pipeline_ )
+ {}
+
+ ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( displayProperties == rhs.displayProperties );
+ memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
}
- bool operator!=( DisplayProperties2KHR const& rhs ) const
+ ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+ return *this;
+ }
+ ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ {
+ type = type_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eDisplayProperties2KHR;
-
- public:
- void* pNext = nullptr;
- DisplayPropertiesKHR displayProperties;
- };
- static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
+ ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
- enum class DebugReportFlagBitsEXT
- {
- eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
- eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
- ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
- eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
- eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
- };
+ ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ )
+ {
+ pipeline = pipeline_;
+ return *this;
+ }
- using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
+ operator VkObjectTablePipelineEntryNVX const&() const
+ {
+ return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
+ }
- VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
- {
- return DebugReportFlagsEXT( bit0 ) | bit1;
- }
+ operator VkObjectTablePipelineEntryNVX &()
+ {
+ return *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this);
+ }
- VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
- {
- return ~( DebugReportFlagsEXT( bits ) );
- }
+ bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
+ {
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( pipeline == rhs.pipeline );
+ }
- template <> struct FlagTraits<DebugReportFlagBitsEXT>
- {
- enum
+ bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
{
- allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
- };
+ return !operator==( rhs );
+ }
+
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ Pipeline pipeline;
};
+ static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
- struct DebugReportCallbackCreateInfoEXT
+ struct ObjectTableDescriptorSetEntryNVX
{
- DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(),
- PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
- void* pUserData_ = nullptr )
- : flags( flags_ )
- , pfnCallback( pfnCallback_ )
- , pUserData( pUserData_ )
+ ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+ ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+ PipelineLayout pipelineLayout_ = PipelineLayout(),
+ DescriptorSet descriptorSet_ = DescriptorSet() )
+ : type( type_ )
+ , flags( flags_ )
+ , pipelineLayout( pipelineLayout_ )
+ , descriptorSet( descriptorSet_ )
{
}
- DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+ PipelineLayout pipelineLayout_ = PipelineLayout(),
+ DescriptorSet descriptorSet_ = DescriptorSet() )
+ : type( objectTableEntryNVX.type )
+ , flags( objectTableEntryNVX.flags )
+ , pipelineLayout( pipelineLayout_ )
+ , descriptorSet( descriptorSet_ )
+ {}
+
+ ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
}
- DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
return *this;
}
- DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
+ ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- pNext = pNext_;
+ type = type_;
return *this;
}
- DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
+ ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
+ ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
{
- pfnCallback = pfnCallback_;
+ pipelineLayout = pipelineLayout_;
return *this;
}
- DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
+ ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ )
{
- pUserData = pUserData_;
+ descriptorSet = descriptorSet_;
return *this;
}
- operator const VkDebugReportCallbackCreateInfoEXT&() const
+ operator VkObjectTableDescriptorSetEntryNVX const&() const
{
- return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
+ return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
}
- bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
+ operator VkObjectTableDescriptorSetEntryNVX &()
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
+ return *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this);
+ }
+
+ bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+ {
+ return ( type == rhs.type )
&& ( flags == rhs.flags )
- && ( pfnCallback == rhs.pfnCallback )
- && ( pUserData == rhs.pUserData );
+ && ( pipelineLayout == rhs.pipelineLayout )
+ && ( descriptorSet == rhs.descriptorSet );
}
- bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
+ bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DebugReportFlagsEXT flags;
- PFN_vkDebugReportCallbackEXT pfnCallback;
- void* pUserData;
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ PipelineLayout pipelineLayout;
+ DescriptorSet descriptorSet;
};
- static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
- enum class DebugReportObjectTypeEXT
+ struct ObjectTableVertexBufferEntryNVX
{
- eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
- eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
- ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
- eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
- eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
- eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
- eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
- eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
- eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
- eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
- eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
- eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
- eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
- eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
- eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
- eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
- ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
- ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
- eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
- ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
- eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
- eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
- eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
- eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
- eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
- eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
- eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
- eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
- eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
- eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
- eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
- eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
- eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
- eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
- eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
- eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
- eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
- eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
- eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
- eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT
+ ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+ ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+ Buffer buffer_ = Buffer() )
+ : type( type_ )
+ , flags( flags_ )
+ , buffer( buffer_ )
+ {
+ }
+
+ explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+ Buffer buffer_ = Buffer() )
+ : type( objectTableEntryNVX.type )
+ , flags( objectTableEntryNVX.flags )
+ , buffer( buffer_ )
+ {}
+
+ ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+ }
+
+ ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+ return *this;
+ }
+ ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ {
+ type = type_;
+ return *this;
+ }
+
+ ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ )
+ {
+ buffer = buffer_;
+ return *this;
+ }
+
+ operator VkObjectTableVertexBufferEntryNVX const&() const
+ {
+ return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
+ }
+
+ operator VkObjectTableVertexBufferEntryNVX &()
+ {
+ return *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this);
+ }
+
+ bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ {
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( buffer == rhs.buffer );
+ }
+
+ bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ Buffer buffer;
};
+ static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
- struct DebugMarkerObjectNameInfoEXT
+ struct ObjectTableIndexBufferEntryNVX
{
- DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
- uint64_t object_ = 0,
- const char* pObjectName_ = nullptr )
- : objectType( objectType_ )
- , object( object_ )
- , pObjectName( pObjectName_ )
+ ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+ ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+ Buffer buffer_ = Buffer(),
+ IndexType indexType_ = IndexType::eUint16 )
+ : type( type_ )
+ , flags( flags_ )
+ , buffer( buffer_ )
+ , indexType( indexType_ )
{
}
- DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+ Buffer buffer_ = Buffer(),
+ IndexType indexType_ = IndexType::eUint16 )
+ : type( objectTableEntryNVX.type )
+ , flags( objectTableEntryNVX.flags )
+ , buffer( buffer_ )
+ , indexType( indexType_ )
+ {}
+
+ ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
+ memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
}
- DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
+ memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
return *this;
}
- DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
+ ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- pNext = pNext_;
+ type = type_;
return *this;
}
- DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
+ ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
- objectType = objectType_;
+ flags = flags_;
return *this;
}
- DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
+ ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ )
{
- object = object_;
+ buffer = buffer_;
return *this;
}
- DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
+ ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ )
{
- pObjectName = pObjectName_;
+ indexType = indexType_;
return *this;
}
- operator const VkDebugMarkerObjectNameInfoEXT&() const
+ operator VkObjectTableIndexBufferEntryNVX const&() const
{
- return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
+ return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
}
- bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
+ operator VkObjectTableIndexBufferEntryNVX &()
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( objectType == rhs.objectType )
- && ( object == rhs.object )
- && ( pObjectName == rhs.pObjectName );
+ return *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this);
}
- bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
+ bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
+ {
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( buffer == rhs.buffer )
+ && ( indexType == rhs.indexType );
+ }
+
+ bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DebugReportObjectTypeEXT objectType;
- uint64_t object;
- const char* pObjectName;
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ Buffer buffer;
+ IndexType indexType;
};
- static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
- struct DebugMarkerObjectTagInfoEXT
+ struct ObjectTablePushConstantEntryNVX
{
- DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
- uint64_t object_ = 0,
- uint64_t tagName_ = 0,
- size_t tagSize_ = 0,
- const void* pTag_ = nullptr )
- : objectType( objectType_ )
- , object( object_ )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
+ ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+ ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+ PipelineLayout pipelineLayout_ = PipelineLayout(),
+ ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+ : type( type_ )
+ , flags( flags_ )
+ , pipelineLayout( pipelineLayout_ )
+ , stageFlags( stageFlags_ )
{
}
- DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
- }
+ explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+ PipelineLayout pipelineLayout_ = PipelineLayout(),
+ ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+ : type( objectTableEntryNVX.type )
+ , flags( objectTableEntryNVX.flags )
+ , pipelineLayout( pipelineLayout_ )
+ , stageFlags( stageFlags_ )
+ {}
- DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
- return *this;
+ memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
}
- DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
+
+ ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
{
- pNext = pNext_;
+ memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
return *this;
}
-
- DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
+ ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
- objectType = objectType_;
+ type = type_;
return *this;
}
- DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
+ ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
{
- object = object_;
+ flags = flags_;
return *this;
}
- DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
+ ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
{
- tagName = tagName_;
+ pipelineLayout = pipelineLayout_;
return *this;
}
- DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
+ ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ )
{
- tagSize = tagSize_;
+ stageFlags = stageFlags_;
return *this;
}
- DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
+ operator VkObjectTablePushConstantEntryNVX const&() const
{
- pTag = pTag_;
- return *this;
+ return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
}
- operator const VkDebugMarkerObjectTagInfoEXT&() const
+ operator VkObjectTablePushConstantEntryNVX &()
{
- return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
+ return *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this);
}
- bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
+ bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( objectType == rhs.objectType )
- && ( object == rhs.object )
- && ( tagName == rhs.tagName )
- && ( tagSize == rhs.tagSize )
- && ( pTag == rhs.pTag );
+ return ( type == rhs.type )
+ && ( flags == rhs.flags )
+ && ( pipelineLayout == rhs.pipelineLayout )
+ && ( stageFlags == rhs.stageFlags );
}
- bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
+ bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
+ ObjectEntryTypeNVX type;
+ ObjectEntryUsageFlagsNVX flags;
+ PipelineLayout pipelineLayout;
+ ShaderStageFlags stageFlags;
+ };
+ static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
- public:
- const void* pNext = nullptr;
- DebugReportObjectTypeEXT objectType;
- uint64_t object;
- uint64_t tagName;
- size_t tagSize;
- const void* pTag;
+ enum class DescriptorSetLayoutCreateFlagBits
+ {
+ ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
+ eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
};
- static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
- enum class RasterizationOrderAMD
+ using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
+
+ VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
{
- eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
- eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
+ return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
+ {
+ return ~( DescriptorSetLayoutCreateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT)
+ };
};
- struct PipelineRasterizationStateRasterizationOrderAMD
+ struct DescriptorSetLayoutCreateInfo
{
- PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
- : rasterizationOrder( rasterizationOrder_ )
+ DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(),
+ uint32_t bindingCount_ = 0,
+ const DescriptorSetLayoutBinding* pBindings_ = nullptr )
+ : flags( flags_ )
+ , bindingCount( bindingCount_ )
+ , pBindings( pBindings_ )
{
}
- PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
}
- PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
return *this;
}
- PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
+ DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
+ DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
{
- rasterizationOrder = rasterizationOrder_;
+ flags = flags_;
return *this;
}
- operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
+ DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
{
- return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
+ bindingCount = bindingCount_;
+ return *this;
}
- bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+ DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
+ {
+ pBindings = pBindings_;
+ return *this;
+ }
+
+ operator VkDescriptorSetLayoutCreateInfo const&() const
+ {
+ return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
+ }
+
+ operator VkDescriptorSetLayoutCreateInfo &()
+ {
+ return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this);
+ }
+
+ bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( rasterizationOrder == rhs.rasterizationOrder );
+ && ( flags == rhs.flags )
+ && ( bindingCount == rhs.bindingCount )
+ && ( pBindings == rhs.pBindings );
}
- bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+ bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+ StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
public:
const void* pNext = nullptr;
- RasterizationOrderAMD rasterizationOrder;
+ DescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+ const DescriptorSetLayoutBinding* pBindings;
};
- static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
- enum class ExternalMemoryHandleTypeFlagBitsNV
+ enum class ExternalMemoryHandleTypeFlagBits
{
- eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
- eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
- eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
- eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
+ eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+ eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+ eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
+ eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
+ eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
+ eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
+ eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
+ eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
+ eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
+ eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
+ eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+ eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+ eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+ eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
};
- using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
+ using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits, VkExternalMemoryHandleTypeFlags>;
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
{
- return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
+ return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
+ VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits )
{
- return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
+ return ~( ExternalMemoryHandleTypeFlags( bits ) );
}
- template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
+ template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits>
{
enum
{
- allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
+ allFlags = VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
};
};
- struct ExternalMemoryImageCreateInfoNV
+ using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
+
+ struct PhysicalDeviceExternalImageFormatInfo
{
- ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : handleTypes( handleTypes_ )
+ PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : handleType( handleType_ )
{
}
- ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
+ PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
}
- ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
+ PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
return *this;
}
- ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
+ PhysicalDeviceExternalImageFormatInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ PhysicalDeviceExternalImageFormatInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
{
- handleTypes = handleTypes_;
+ handleType = handleType_;
return *this;
}
- operator const VkExternalMemoryImageCreateInfoNV&() const
+ operator VkPhysicalDeviceExternalImageFormatInfo const&() const
{
- return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(this);
}
- bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
+ operator VkPhysicalDeviceExternalImageFormatInfo &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this);
+ }
+
+ bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
+ bool operator!=( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
+ StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagsNV handleTypes;
+ ExternalMemoryHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
- struct ExportMemoryAllocateInfoNV
+ using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
+
+ struct PhysicalDeviceExternalBufferInfo
{
- ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : handleTypes( handleTypes_ )
+ PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
+ BufferUsageFlags usage_ = BufferUsageFlags(),
+ ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : flags( flags_ )
+ , usage( usage_ )
+ , handleType( handleType_ )
{
}
- ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
+ PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
}
- ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
+ PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
return *this;
}
- ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
+ PhysicalDeviceExternalBufferInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ PhysicalDeviceExternalBufferInfo& setFlags( BufferCreateFlags flags_ )
{
- handleTypes = handleTypes_;
+ flags = flags_;
return *this;
}
- operator const VkExportMemoryAllocateInfoNV&() const
+ PhysicalDeviceExternalBufferInfo& setUsage( BufferUsageFlags usage_ )
{
- return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
+ usage = usage_;
+ return *this;
}
- bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
+ PhysicalDeviceExternalBufferInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ {
+ handleType = handleType_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceExternalBufferInfo const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(this);
+ }
+
+ operator VkPhysicalDeviceExternalBufferInfo &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this);
+ }
+
+ bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ && ( flags == rhs.flags )
+ && ( usage == rhs.usage )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
+ bool operator!=( PhysicalDeviceExternalBufferInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
+ StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagsNV handleTypes;
+ BufferCreateFlags flags;
+ BufferUsageFlags usage;
+ ExternalMemoryHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
-#ifdef VK_USE_PLATFORM_WIN32_NV
- struct ImportMemoryWin32HandleInfoNV
+ using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
+
+ struct ExternalMemoryImageCreateInfo
{
- ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
- HANDLE handle_ = 0 )
- : handleType( handleType_ )
- , handle( handle_ )
+ ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
{
}
- ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
+ ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
}
- ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
+ ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
return *this;
}
- ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
+ ExternalMemoryImageCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
+ ExternalMemoryImageCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
{
- handleType = handleType_;
+ handleTypes = handleTypes_;
return *this;
}
- ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
+ operator VkExternalMemoryImageCreateInfo const&() const
{
- handle = handle_;
- return *this;
+ return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(this);
}
- operator const VkImportMemoryWin32HandleInfoNV&() const
+ operator VkExternalMemoryImageCreateInfo &()
{
- return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
+ return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this);
}
- bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
+ bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleType == rhs.handleType )
- && ( handle == rhs.handle );
+ && ( handleTypes == rhs.handleTypes );
}
- bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
+ bool operator!=( ExternalMemoryImageCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
+ StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagsNV handleType;
- HANDLE handle;
- };
- static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_NV*/
-
- enum class ExternalMemoryFeatureFlagBitsNV
- {
- eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
- eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
- eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
- };
-
- using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
-
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
- {
- return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
- {
- return ~( ExternalMemoryFeatureFlagsNV( bits ) );
- }
-
- template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
- {
- enum
- {
- allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
- };
- };
-
- struct ExternalImageFormatPropertiesNV
- {
- operator const VkExternalImageFormatPropertiesNV&() const
- {
- return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
- }
-
- bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
- {
- return ( imageFormatProperties == rhs.imageFormatProperties )
- && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
- && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
- && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
- }
-
- bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- ImageFormatProperties imageFormatProperties;
- ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
- ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
- ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
+ ExternalMemoryHandleTypeFlags handleTypes;
};
- static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
- enum class ValidationCheckEXT
- {
- eAll = VK_VALIDATION_CHECK_ALL_EXT,
- eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
- };
+ using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
- struct ValidationFlagsEXT
+ struct ExternalMemoryBufferCreateInfo
{
- ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
- const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
- : disabledValidationCheckCount( disabledValidationCheckCount_ )
- , pDisabledValidationChecks( pDisabledValidationChecks_ )
+ ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
{
}
- ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
+ ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
}
- ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
+ ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
return *this;
}
- ValidationFlagsEXT& setPNext( const void* pNext_ )
+ ExternalMemoryBufferCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
+ ExternalMemoryBufferCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
{
- disabledValidationCheckCount = disabledValidationCheckCount_;
+ handleTypes = handleTypes_;
return *this;
}
- ValidationFlagsEXT& setPDisabledValidationChecks( const ValidationCheckEXT* pDisabledValidationChecks_ )
+ operator VkExternalMemoryBufferCreateInfo const&() const
{
- pDisabledValidationChecks = pDisabledValidationChecks_;
- return *this;
+ return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(this);
}
- operator const VkValidationFlagsEXT&() const
+ operator VkExternalMemoryBufferCreateInfo &()
{
- return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
+ return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this);
}
- bool operator==( ValidationFlagsEXT const& rhs ) const
+ bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
- && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+ && ( handleTypes == rhs.handleTypes );
}
- bool operator!=( ValidationFlagsEXT const& rhs ) const
+ bool operator!=( ExternalMemoryBufferCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eValidationFlagsEXT;
+ StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
public:
const void* pNext = nullptr;
- uint32_t disabledValidationCheckCount;
- const ValidationCheckEXT* pDisabledValidationChecks;
- };
- static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
-
- enum class SubgroupFeatureFlagBits
- {
- eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT,
- eVote = VK_SUBGROUP_FEATURE_VOTE_BIT,
- eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT,
- eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT,
- eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT,
- eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT,
- eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT,
- eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT,
- ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
+ ExternalMemoryHandleTypeFlags handleTypes;
};
+ static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
- using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits, VkSubgroupFeatureFlags>;
+ using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
- VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+ struct ExportMemoryAllocateInfo
{
- return SubgroupFeatureFlags( bit0 ) | bit1;
- }
+ ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
+ {
+ }
- VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits )
- {
- return ~( SubgroupFeatureFlags( bits ) );
- }
+ ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+ }
+
+ ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+ return *this;
+ }
+ ExportMemoryAllocateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- template <> struct FlagTraits<SubgroupFeatureFlagBits>
- {
- enum
+ ExportMemoryAllocateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
{
- allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) | VkFlags(SubgroupFeatureFlagBits::eVote) | VkFlags(SubgroupFeatureFlagBits::eArithmetic) | VkFlags(SubgroupFeatureFlagBits::eBallot) | VkFlags(SubgroupFeatureFlagBits::eShuffle) | VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) | VkFlags(SubgroupFeatureFlagBits::eClustered) | VkFlags(SubgroupFeatureFlagBits::eQuad) | VkFlags(SubgroupFeatureFlagBits::ePartitionedNV)
- };
- };
+ handleTypes = handleTypes_;
+ return *this;
+ }
- struct PhysicalDeviceSubgroupProperties
- {
- operator const VkPhysicalDeviceSubgroupProperties&() const
+ operator VkExportMemoryAllocateInfo const&() const
{
- return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(this);
+ return *reinterpret_cast<const VkExportMemoryAllocateInfo*>(this);
}
- bool operator==( PhysicalDeviceSubgroupProperties const& rhs ) const
+ operator VkExportMemoryAllocateInfo &()
+ {
+ return *reinterpret_cast<VkExportMemoryAllocateInfo*>(this);
+ }
+
+ bool operator==( ExportMemoryAllocateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( subgroupSize == rhs.subgroupSize )
- && ( supportedStages == rhs.supportedStages )
- && ( supportedOperations == rhs.supportedOperations )
- && ( quadOperationsInAllStages == rhs.quadOperationsInAllStages );
+ && ( handleTypes == rhs.handleTypes );
}
- bool operator!=( PhysicalDeviceSubgroupProperties const& rhs ) const
+ bool operator!=( ExportMemoryAllocateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
+ StructureType sType = StructureType::eExportMemoryAllocateInfo;
public:
- void* pNext = nullptr;
- uint32_t subgroupSize;
- ShaderStageFlags supportedStages;
- SubgroupFeatureFlags supportedOperations;
- Bool32 quadOperationsInAllStages;
- };
- static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" );
-
- enum class IndirectCommandsLayoutUsageFlagBitsNVX
- {
- eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
- eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
- eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
- eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
+ const void* pNext = nullptr;
+ ExternalMemoryHandleTypeFlags handleTypes;
};
+ static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
- using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
-
- VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
- {
- return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
- {
- return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
- }
+ using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
- template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct ImportMemoryWin32HandleInfoKHR
{
- enum
+ ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = 0 )
+ : handleType( handleType_ )
+ , handle( handle_ )
+ , name( name_ )
{
- allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
- };
- };
-
- enum class ObjectEntryUsageFlagBitsNVX
- {
- eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
- eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
- };
-
- using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
-
- VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
- {
- return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
- {
- return ~( ObjectEntryUsageFlagsNVX( bits ) );
- }
+ }
- template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
- {
- enum
+ ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
{
- allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
- };
- };
-
- enum class IndirectCommandsTokenTypeNVX
- {
- ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
- eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
- eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
- eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
- ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
- eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
- eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
- eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
- };
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+ }
- struct IndirectCommandsTokenNVX
- {
- IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
- Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0 )
- : tokenType( tokenType_ )
- , buffer( buffer_ )
- , offset( offset_ )
+ ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
{
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+ return *this;
}
-
- IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
+ ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
+ pNext = pNext_;
+ return *this;
}
- IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
+ ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
+ handleType = handleType_;
return *this;
}
- IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+
+ ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ )
{
- tokenType = tokenType_;
+ handle = handle_;
return *this;
}
- IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ )
+ ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
{
- buffer = buffer_;
+ name = name_;
return *this;
}
- IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ )
+ operator VkImportMemoryWin32HandleInfoKHR const&() const
{
- offset = offset_;
- return *this;
+ return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this);
}
- operator const VkIndirectCommandsTokenNVX&() const
+ operator VkImportMemoryWin32HandleInfoKHR &()
{
- return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
+ return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this);
}
- bool operator==( IndirectCommandsTokenNVX const& rhs ) const
+ bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
{
- return ( tokenType == rhs.tokenType )
- && ( buffer == rhs.buffer )
- && ( offset == rhs.offset );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleType == rhs.handleType )
+ && ( handle == rhs.handle )
+ && ( name == rhs.name );
}
- bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
+ bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
- IndirectCommandsTokenTypeNVX tokenType;
- Buffer buffer;
- DeviceSize offset;
+ private:
+ StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
+
+ public:
+ const void* pNext = nullptr;
+ ExternalMemoryHandleTypeFlagBits handleType;
+ HANDLE handle;
+ LPCWSTR name;
};
- static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct IndirectCommandsLayoutTokenNVX
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct MemoryGetWin32HandleInfoKHR
{
- IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
- uint32_t bindingUnit_ = 0,
- uint32_t dynamicCount_ = 0,
- uint32_t divisor_ = 0 )
- : tokenType( tokenType_ )
- , bindingUnit( bindingUnit_ )
- , dynamicCount( dynamicCount_ )
- , divisor( divisor_ )
+ MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
+ ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : memory( memory_ )
+ , handleType( handleType_ )
{
}
- IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
+ MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
+ memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
}
- IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
+ MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
+ memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
return *this;
}
- IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
{
- tokenType = tokenType_;
+ pNext = pNext_;
return *this;
}
- IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ )
+ MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ )
{
- bindingUnit = bindingUnit_;
+ memory = memory_;
return *this;
}
- IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ )
+ MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
{
- dynamicCount = dynamicCount_;
+ handleType = handleType_;
return *this;
}
- IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ )
+ operator VkMemoryGetWin32HandleInfoKHR const&() const
{
- divisor = divisor_;
- return *this;
+ return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this);
}
- operator const VkIndirectCommandsLayoutTokenNVX&() const
+ operator VkMemoryGetWin32HandleInfoKHR &()
{
- return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
+ return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this);
}
- bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
+ bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
{
- return ( tokenType == rhs.tokenType )
- && ( bindingUnit == rhs.bindingUnit )
- && ( dynamicCount == rhs.dynamicCount )
- && ( divisor == rhs.divisor );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memory == rhs.memory )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
+ bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
- IndirectCommandsTokenTypeNVX tokenType;
- uint32_t bindingUnit;
- uint32_t dynamicCount;
- uint32_t divisor;
+ private:
+ StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
+
+ public:
+ const void* pNext = nullptr;
+ DeviceMemory memory;
+ ExternalMemoryHandleTypeFlagBits handleType;
};
- static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct IndirectCommandsLayoutCreateInfoNVX
+ struct ImportMemoryFdInfoKHR
{
- IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(),
- uint32_t tokenCount_ = 0,
- const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
- : pipelineBindPoint( pipelineBindPoint_ )
- , flags( flags_ )
- , tokenCount( tokenCount_ )
- , pTokens( pTokens_ )
+ ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : handleType( handleType_ )
+ , fd( fd_ )
{
}
- IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+ ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
+ memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
}
- IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+ ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
+ memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
+ ImportMemoryFdInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
- {
- pipelineBindPoint = pipelineBindPoint_;
- return *this;
- }
-
- IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
+ ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
{
- flags = flags_;
+ handleType = handleType_;
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ )
+ ImportMemoryFdInfoKHR& setFd( int fd_ )
{
- tokenCount = tokenCount_;
+ fd = fd_;
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
+ operator VkImportMemoryFdInfoKHR const&() const
{
- pTokens = pTokens_;
- return *this;
+ return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this);
}
- operator const VkIndirectCommandsLayoutCreateInfoNVX&() const
+ operator VkImportMemoryFdInfoKHR &()
{
- return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
+ return *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this);
}
- bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
+ bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( pipelineBindPoint == rhs.pipelineBindPoint )
- && ( flags == rhs.flags )
- && ( tokenCount == rhs.tokenCount )
- && ( pTokens == rhs.pTokens );
+ && ( handleType == rhs.handleType )
+ && ( fd == rhs.fd );
}
- bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
+ bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
+ StructureType sType = StructureType::eImportMemoryFdInfoKHR;
public:
const void* pNext = nullptr;
- PipelineBindPoint pipelineBindPoint;
- IndirectCommandsLayoutUsageFlagsNVX flags;
- uint32_t tokenCount;
- const IndirectCommandsLayoutTokenNVX* pTokens;
- };
- static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
-
- enum class ObjectEntryTypeNVX
- {
- eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
- ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX,
- eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX,
- eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX,
- ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
+ ExternalMemoryHandleTypeFlagBits handleType;
+ int fd;
};
+ static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
- struct ObjectTableCreateInfoNVX
+ struct MemoryGetFdInfoKHR
{
- ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
- const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
- const uint32_t* pObjectEntryCounts_ = nullptr,
- const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
- uint32_t maxUniformBuffersPerDescriptor_ = 0,
- uint32_t maxStorageBuffersPerDescriptor_ = 0,
- uint32_t maxStorageImagesPerDescriptor_ = 0,
- uint32_t maxSampledImagesPerDescriptor_ = 0,
- uint32_t maxPipelineLayouts_ = 0 )
- : objectCount( objectCount_ )
- , pObjectEntryTypes( pObjectEntryTypes_ )
- , pObjectEntryCounts( pObjectEntryCounts_ )
- , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
- , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
- , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
- , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
- , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
- , maxPipelineLayouts( maxPipelineLayouts_ )
+ MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(),
+ ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : memory( memory_ )
+ , handleType( handleType_ )
{
}
- ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
+ MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
+ memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
}
- ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
+ MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
+ memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
return *this;
}
- ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
+ MemoryGetFdInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ )
+ MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ )
{
- objectCount = objectCount_;
+ memory = memory_;
return *this;
}
- ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
+ MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
{
- pObjectEntryTypes = pObjectEntryTypes_;
+ handleType = handleType_;
return *this;
}
- ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
+ operator VkMemoryGetFdInfoKHR const&() const
{
- pObjectEntryCounts = pObjectEntryCounts_;
- return *this;
+ return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this);
}
- ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
+ operator VkMemoryGetFdInfoKHR &()
{
- pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
- return *this;
+ return *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this);
}
- ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
+ bool operator==( MemoryGetFdInfoKHR const& rhs ) const
{
- maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memory == rhs.memory )
+ && ( handleType == rhs.handleType );
}
- ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
+ bool operator!=( MemoryGetFdInfoKHR const& rhs ) const
{
- maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
- return *this;
+ return !operator==( rhs );
}
- ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
+ private:
+ StructureType sType = StructureType::eMemoryGetFdInfoKHR;
+
+ public:
+ const void* pNext = nullptr;
+ DeviceMemory memory;
+ ExternalMemoryHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
+
+ struct ImportMemoryHostPointerInfoEXT
+ {
+ ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ void* pHostPointer_ = nullptr )
+ : handleType( handleType_ )
+ , pHostPointer( pHostPointer_ )
{
- maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
+ }
+
+ ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
+ }
+
+ ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
+ return *this;
+ }
+ ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
+ ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
{
- maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
+ handleType = handleType_;
return *this;
}
- ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
+ ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ )
{
- maxPipelineLayouts = maxPipelineLayouts_;
+ pHostPointer = pHostPointer_;
return *this;
}
- operator const VkObjectTableCreateInfoNVX&() const
+ operator VkImportMemoryHostPointerInfoEXT const&() const
{
- return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
+ return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
}
- bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
+ operator VkImportMemoryHostPointerInfoEXT &()
+ {
+ return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this);
+ }
+
+ bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( objectCount == rhs.objectCount )
- && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
- && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
- && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
- && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
- && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
- && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
- && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
- && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
+ && ( handleType == rhs.handleType )
+ && ( pHostPointer == rhs.pHostPointer );
}
- bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
+ bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eObjectTableCreateInfoNVX;
+ StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
public:
const void* pNext = nullptr;
- uint32_t objectCount;
- const ObjectEntryTypeNVX* pObjectEntryTypes;
- const uint32_t* pObjectEntryCounts;
- const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
- uint32_t maxUniformBuffersPerDescriptor;
- uint32_t maxStorageBuffersPerDescriptor;
- uint32_t maxStorageImagesPerDescriptor;
- uint32_t maxSampledImagesPerDescriptor;
- uint32_t maxPipelineLayouts;
+ ExternalMemoryHandleTypeFlagBits handleType;
+ void* pHostPointer;
};
- static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
- struct ObjectTableEntryNVX
+ enum class ExternalMemoryFeatureFlagBits
{
- ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
- : type( type_ )
- , flags( flags_ )
- {
- }
+ eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
+ eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
+ eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
+ eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
+ eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+ eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
+ };
- ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
- }
+ using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits, VkExternalMemoryFeatureFlags>;
- ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
- return *this;
- }
- ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ {
+ return ExternalMemoryFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits )
+ {
+ return ~( ExternalMemoryFeatureFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalMemoryFeatureFlagBits>
+ {
+ enum
{
- type = type_;
- return *this;
- }
+ allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBits::eExportable) | VkFlags(ExternalMemoryFeatureFlagBits::eImportable)
+ };
+ };
- ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
+
+ struct ExternalMemoryProperties
+ {
+ operator VkExternalMemoryProperties const&() const
{
- flags = flags_;
- return *this;
+ return *reinterpret_cast<const VkExternalMemoryProperties*>(this);
}
- operator const VkObjectTableEntryNVX&() const
+ operator VkExternalMemoryProperties &()
{
- return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
+ return *reinterpret_cast<VkExternalMemoryProperties*>(this);
}
- bool operator==( ObjectTableEntryNVX const& rhs ) const
+ bool operator==( ExternalMemoryProperties const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags );
+ return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
}
- bool operator!=( ObjectTableEntryNVX const& rhs ) const
+ bool operator!=( ExternalMemoryProperties const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
+ ExternalMemoryFeatureFlags externalMemoryFeatures;
+ ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
+ ExternalMemoryHandleTypeFlags compatibleHandleTypes;
};
- static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
- struct ObjectTablePipelineEntryNVX
+ using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
+
+ struct ExternalImageFormatProperties
{
- ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- Pipeline pipeline_ = Pipeline() )
- : type( type_ )
- , flags( flags_ )
- , pipeline( pipeline_ )
+ operator VkExternalImageFormatProperties const&() const
{
+ return *reinterpret_cast<const VkExternalImageFormatProperties*>(this);
}
- explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- Pipeline pipeline_ = Pipeline() )
- : type( objectTableEntryNVX.type )
- , flags( objectTableEntryNVX.flags )
- , pipeline( pipeline_ )
- {}
-
- ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
+ operator VkExternalImageFormatProperties &()
{
- memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+ return *reinterpret_cast<VkExternalImageFormatProperties*>(this);
}
- ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
- return *this;
- }
- ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ bool operator==( ExternalImageFormatProperties const& rhs ) const
{
- type = type_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( externalMemoryProperties == rhs.externalMemoryProperties );
}
- ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ bool operator!=( ExternalImageFormatProperties const& rhs ) const
{
- flags = flags_;
- return *this;
+ return !operator==( rhs );
}
- ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ )
+ private:
+ StructureType sType = StructureType::eExternalImageFormatProperties;
+
+ public:
+ void* pNext = nullptr;
+ ExternalMemoryProperties externalMemoryProperties;
+ };
+ static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
+
+ using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
+
+ struct ExternalBufferProperties
+ {
+ operator VkExternalBufferProperties const&() const
{
- pipeline = pipeline_;
- return *this;
+ return *reinterpret_cast<const VkExternalBufferProperties*>(this);
}
- operator const VkObjectTablePipelineEntryNVX&() const
+ operator VkExternalBufferProperties &()
{
- return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
+ return *reinterpret_cast<VkExternalBufferProperties*>(this);
}
- bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
+ bool operator==( ExternalBufferProperties const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( pipeline == rhs.pipeline );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( externalMemoryProperties == rhs.externalMemoryProperties );
}
- bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
+ bool operator!=( ExternalBufferProperties const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Pipeline pipeline;
+ private:
+ StructureType sType = StructureType::eExternalBufferProperties;
+
+ public:
+ void* pNext = nullptr;
+ ExternalMemoryProperties externalMemoryProperties;
};
- static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
- struct ObjectTableDescriptorSetEntryNVX
+ using ExternalBufferPropertiesKHR = ExternalBufferProperties;
+
+ enum class ExternalSemaphoreHandleTypeFlagBits
{
- ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- DescriptorSet descriptorSet_ = DescriptorSet() )
- : type( type_ )
- , flags( flags_ )
- , pipelineLayout( pipelineLayout_ )
- , descriptorSet( descriptorSet_ )
+ eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
+ eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
+ eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+ eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+ eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+ eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ };
+
+ using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreHandleTypeFlags>;
+
+ VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+ {
+ return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits )
+ {
+ return ~( ExternalSemaphoreHandleTypeFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits>
+ {
+ enum
{
- }
+ allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
+ };
+ };
- explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- DescriptorSet descriptorSet_ = DescriptorSet() )
- : type( objectTableEntryNVX.type )
- , flags( objectTableEntryNVX.flags )
- , pipelineLayout( pipelineLayout_ )
- , descriptorSet( descriptorSet_ )
- {}
+ using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
- ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
+ struct PhysicalDeviceExternalSemaphoreInfo
+ {
+ PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : handleType( handleType_ )
{
- memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
}
- ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
+ PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
- return *this;
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
}
- ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
+
+ PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
{
- type = type_;
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
return *this;
}
-
- ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ PhysicalDeviceExternalSemaphoreInfo& setPNext( const void* pNext_ )
{
- flags = flags_;
+ pNext = pNext_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
+ PhysicalDeviceExternalSemaphoreInfo& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
- pipelineLayout = pipelineLayout_;
+ handleType = handleType_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ )
+ operator VkPhysicalDeviceExternalSemaphoreInfo const&() const
{
- descriptorSet = descriptorSet_;
- return *this;
+ return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(this);
}
- operator const VkObjectTableDescriptorSetEntryNVX&() const
+ operator VkPhysicalDeviceExternalSemaphoreInfo &()
{
- return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
+ return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this);
}
- bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+ bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( pipelineLayout == rhs.pipelineLayout )
- && ( descriptorSet == rhs.descriptorSet );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+ bool operator!=( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- PipelineLayout pipelineLayout;
- DescriptorSet descriptorSet;
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
+
+ public:
+ const void* pNext = nullptr;
+ ExternalSemaphoreHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
- struct ObjectTableVertexBufferEntryNVX
+ using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
+
+ struct ExportSemaphoreCreateInfo
{
- ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- Buffer buffer_ = Buffer() )
- : type( type_ )
- , flags( flags_ )
- , buffer( buffer_ )
+ ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
{
}
- explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- Buffer buffer_ = Buffer() )
- : type( objectTableEntryNVX.type )
- , flags( objectTableEntryNVX.flags )
- , buffer( buffer_ )
- {}
-
- ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
+ ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+ memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
}
- ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
+ ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+ memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
return *this;
}
- ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ ExportSemaphoreCreateInfo& setPNext( const void* pNext_ )
{
- type = type_;
+ pNext = pNext_;
return *this;
}
- ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ExportSemaphoreCreateInfo& setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ )
{
- flags = flags_;
+ handleTypes = handleTypes_;
return *this;
}
- ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ )
+ operator VkExportSemaphoreCreateInfo const&() const
{
- buffer = buffer_;
- return *this;
+ return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>(this);
}
- operator const VkObjectTableVertexBufferEntryNVX&() const
+ operator VkExportSemaphoreCreateInfo &()
{
- return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
+ return *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this);
}
- bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ bool operator==( ExportSemaphoreCreateInfo const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( buffer == rhs.buffer );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( handleTypes == rhs.handleTypes );
}
- bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
+ bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Buffer buffer;
+ private:
+ StructureType sType = StructureType::eExportSemaphoreCreateInfo;
+
+ public:
+ const void* pNext = nullptr;
+ ExternalSemaphoreHandleTypeFlags handleTypes;
};
- static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
- struct ObjectTableIndexBufferEntryNVX
+ using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct SemaphoreGetWin32HandleInfoKHR
{
- ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- Buffer buffer_ = Buffer(),
- IndexType indexType_ = IndexType::eUint16 )
- : type( type_ )
- , flags( flags_ )
- , buffer( buffer_ )
- , indexType( indexType_ )
+ SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
+ ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : semaphore( semaphore_ )
+ , handleType( handleType_ )
{
}
- explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- Buffer buffer_ = Buffer(),
- IndexType indexType_ = IndexType::eUint16 )
- : type( objectTableEntryNVX.type )
- , flags( objectTableEntryNVX.flags )
- , buffer( buffer_ )
- , indexType( indexType_ )
- {}
-
- ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
+ SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
+ memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
}
- ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
+ SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
+ memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
return *this;
}
- ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
{
- type = type_;
+ pNext = pNext_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
{
- flags = flags_;
+ semaphore = semaphore_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ )
+ SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
- buffer = buffer_;
+ handleType = handleType_;
return *this;
}
- ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ )
+ operator VkSemaphoreGetWin32HandleInfoKHR const&() const
{
- indexType = indexType_;
- return *this;
+ return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this);
}
- operator const VkObjectTableIndexBufferEntryNVX&() const
+ operator VkSemaphoreGetWin32HandleInfoKHR &()
{
- return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
+ return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this);
}
- bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
+ bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( buffer == rhs.buffer )
- && ( indexType == rhs.indexType );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( semaphore == rhs.semaphore )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
+ bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Buffer buffer;
- IndexType indexType;
+ private:
+ StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+
+ public:
+ const void* pNext = nullptr;
+ Semaphore semaphore;
+ ExternalSemaphoreHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct ObjectTablePushConstantEntryNVX
+ struct SemaphoreGetFdInfoKHR
{
- ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- ShaderStageFlags stageFlags_ = ShaderStageFlags() )
- : type( type_ )
- , flags( flags_ )
- , pipelineLayout( pipelineLayout_ )
- , stageFlags( stageFlags_ )
+ SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(),
+ ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : semaphore( semaphore_ )
+ , handleType( handleType_ )
{
}
- explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- ShaderStageFlags stageFlags_ = ShaderStageFlags() )
- : type( objectTableEntryNVX.type )
- , flags( objectTableEntryNVX.flags )
- , pipelineLayout( pipelineLayout_ )
- , stageFlags( stageFlags_ )
- {}
-
- ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
+ SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
+ memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
}
- ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
+ SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
+ memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
return *this;
}
- ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
+ SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ )
{
- type = type_;
+ pNext = pNext_;
return *this;
}
- ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ )
{
- flags = flags_;
+ semaphore = semaphore_;
return *this;
}
- ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
+ SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
- pipelineLayout = pipelineLayout_;
+ handleType = handleType_;
return *this;
}
- ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ )
+ operator VkSemaphoreGetFdInfoKHR const&() const
{
- stageFlags = stageFlags_;
- return *this;
+ return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this);
}
- operator const VkObjectTablePushConstantEntryNVX&() const
+ operator VkSemaphoreGetFdInfoKHR &()
{
- return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
+ return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this);
}
- bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
+ bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
{
- return ( type == rhs.type )
- && ( flags == rhs.flags )
- && ( pipelineLayout == rhs.pipelineLayout )
- && ( stageFlags == rhs.stageFlags );
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( semaphore == rhs.semaphore )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
+ bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- PipelineLayout pipelineLayout;
- ShaderStageFlags stageFlags;
+ private:
+ StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
+
+ public:
+ const void* pNext = nullptr;
+ Semaphore semaphore;
+ ExternalSemaphoreHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
- enum class DescriptorSetLayoutCreateFlagBits
+ enum class ExternalSemaphoreFeatureFlagBits
{
- ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
- eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
+ eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
+ eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
+ eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
+ eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
};
- using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
+ using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits, VkExternalSemaphoreFeatureFlags>;
- VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+ VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
{
- return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
+ return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
+ VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits )
{
- return ~( DescriptorSetLayoutCreateFlags( bits ) );
+ return ~( ExternalSemaphoreFeatureFlags( bits ) );
}
- template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
+ template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits>
{
enum
{
- allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT)
+ allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable)
};
};
- struct DescriptorSetLayoutCreateInfo
- {
- DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(),
- uint32_t bindingCount_ = 0,
- const DescriptorSetLayoutBinding* pBindings_ = nullptr )
- : flags( flags_ )
- , bindingCount( bindingCount_ )
- , pBindings( pBindings_ )
- {
- }
-
- DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
- }
-
- DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
- return *this;
- }
- DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
-
- DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
- {
- bindingCount = bindingCount_;
- return *this;
- }
+ using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
- DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
+ struct ExternalSemaphoreProperties
+ {
+ operator VkExternalSemaphoreProperties const&() const
{
- pBindings = pBindings_;
- return *this;
+ return *reinterpret_cast<const VkExternalSemaphoreProperties*>(this);
}
- operator const VkDescriptorSetLayoutCreateInfo&() const
+ operator VkExternalSemaphoreProperties &()
{
- return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
+ return *reinterpret_cast<VkExternalSemaphoreProperties*>(this);
}
- bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
+ bool operator==( ExternalSemaphoreProperties const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( bindingCount == rhs.bindingCount )
- && ( pBindings == rhs.pBindings );
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
+ && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
}
- bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
+ bool operator!=( ExternalSemaphoreProperties const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
+ StructureType sType = StructureType::eExternalSemaphoreProperties;
public:
- const void* pNext = nullptr;
- DescriptorSetLayoutCreateFlags flags;
- uint32_t bindingCount;
- const DescriptorSetLayoutBinding* pBindings;
+ void* pNext = nullptr;
+ ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+ ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+ ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
};
- static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
- enum class ExternalMemoryHandleTypeFlagBits
+ using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
+
+ enum class SemaphoreImportFlagBits
{
- eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
- eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
- eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
- eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
- eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
- eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
- eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
- eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
- eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
- eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
- eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
- eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
- eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
- eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
- eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
- eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
- eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
- eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
+ eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
+ eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
};
- using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits, VkExternalMemoryHandleTypeFlags>;
+ using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits, VkSemaphoreImportFlags>;
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+ VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
{
- return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
+ return SemaphoreImportFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits )
+ VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits )
{
- return ~( ExternalMemoryHandleTypeFlags( bits ) );
+ return ~( SemaphoreImportFlags( bits ) );
}
- template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits>
+ template <> struct FlagTraits<SemaphoreImportFlagBits>
{
enum
{
- allFlags = VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
+ allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary)
};
};
- using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
+ using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
- struct PhysicalDeviceExternalImageFormatInfo
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct ImportSemaphoreWin32HandleInfoKHR
{
- PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : handleType( handleType_ )
+ ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
+ SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
+ ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = 0 )
+ : semaphore( semaphore_ )
+ , flags( flags_ )
+ , handleType( handleType_ )
+ , handle( handle_ )
+ , name( name_ )
{
}
- PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
+ ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
}
- PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
+ ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
return *this;
}
- PhysicalDeviceExternalImageFormatInfo& setPNext( const void* pNext_ )
+ ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceExternalImageFormatInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
+ {
+ semaphore = semaphore_;
+ return *this;
+ }
+
+ ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
}
- operator const VkPhysicalDeviceExternalImageFormatInfo&() const
+ ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(this);
+ handle = handle_;
+ return *this;
}
- bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
+ ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
+ {
+ name = name_;
+ return *this;
+ }
+
+ operator VkImportSemaphoreWin32HandleInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this);
+ }
+
+ operator VkImportSemaphoreWin32HandleInfoKHR &()
+ {
+ return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this);
+ }
+
+ bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleType == rhs.handleType );
+ && ( semaphore == rhs.semaphore )
+ && ( flags == rhs.flags )
+ && ( handleType == rhs.handleType )
+ && ( handle == rhs.handle )
+ && ( name == rhs.name );
}
- bool operator!=( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
+ bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
+ StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
+ Semaphore semaphore;
+ SemaphoreImportFlags flags;
+ ExternalSemaphoreHandleTypeFlagBits handleType;
+ HANDLE handle;
+ LPCWSTR name;
};
- static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
-
- using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
+ static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct PhysicalDeviceExternalBufferInfo
+ struct ImportSemaphoreFdInfoKHR
{
- PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
- BufferUsageFlags usage_ = BufferUsageFlags(),
- ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : flags( flags_ )
- , usage( usage_ )
+ ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(),
+ SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
+ ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : semaphore( semaphore_ )
+ , flags( flags_ )
, handleType( handleType_ )
+ , fd( fd_ )
{
}
- PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
+ ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
}
- PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
+ ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
return *this;
}
- PhysicalDeviceExternalBufferInfo& setPNext( const void* pNext_ )
+ ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceExternalBufferInfo& setFlags( BufferCreateFlags flags_ )
+ ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ )
{
- flags = flags_;
+ semaphore = semaphore_;
return *this;
}
- PhysicalDeviceExternalBufferInfo& setUsage( BufferUsageFlags usage_ )
+ ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlags flags_ )
{
- usage = usage_;
+ flags = flags_;
return *this;
}
- PhysicalDeviceExternalBufferInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
}
- operator const VkPhysicalDeviceExternalBufferInfo&() const
+ ImportSemaphoreFdInfoKHR& setFd( int fd_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(this);
+ fd = fd_;
+ return *this;
}
- bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const
+ operator VkImportSemaphoreFdInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this);
+ }
+
+ operator VkImportSemaphoreFdInfoKHR &()
+ {
+ return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this);
+ }
+
+ bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
+ && ( semaphore == rhs.semaphore )
&& ( flags == rhs.flags )
- && ( usage == rhs.usage )
- && ( handleType == rhs.handleType );
+ && ( handleType == rhs.handleType )
+ && ( fd == rhs.fd );
}
- bool operator!=( PhysicalDeviceExternalBufferInfo const& rhs ) const
+ bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
+ StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
public:
const void* pNext = nullptr;
- BufferCreateFlags flags;
- BufferUsageFlags usage;
- ExternalMemoryHandleTypeFlagBits handleType;
+ Semaphore semaphore;
+ SemaphoreImportFlags flags;
+ ExternalSemaphoreHandleTypeFlagBits handleType;
+ int fd;
};
- static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
- using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
+ enum class ExternalFenceHandleTypeFlagBits
+ {
+ eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
+ eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
+ eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
+ eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ };
- struct ExternalMemoryImageCreateInfo
+ using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits, VkExternalFenceHandleTypeFlags>;
+
+ VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
{
- ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits )
+ {
+ return ~( ExternalFenceHandleTypeFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd)
+ };
+ };
+
+ using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
+
+ struct PhysicalDeviceExternalFenceInfo
+ {
+ PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : handleType( handleType_ )
{
}
- ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
+ PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
}
- ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
+ PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
return *this;
}
- ExternalMemoryImageCreateInfo& setPNext( const void* pNext_ )
+ PhysicalDeviceExternalFenceInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExternalMemoryImageCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+ PhysicalDeviceExternalFenceInfo& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
{
- handleTypes = handleTypes_;
+ handleType = handleType_;
return *this;
}
- operator const VkExternalMemoryImageCreateInfo&() const
+ operator VkPhysicalDeviceExternalFenceInfo const&() const
{
- return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(this);
}
- bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const
+ operator VkPhysicalDeviceExternalFenceInfo &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this);
+ }
+
+ bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ExternalMemoryImageCreateInfo const& rhs ) const
+ bool operator!=( PhysicalDeviceExternalFenceInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
+ StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlags handleTypes;
+ ExternalFenceHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
- using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
+ using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
- struct ExternalMemoryBufferCreateInfo
+ struct ExportFenceCreateInfo
{
- ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+ ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() )
: handleTypes( handleTypes_ )
{
}
- ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
+ ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
}
- ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
+ ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
return *this;
}
- ExternalMemoryBufferCreateInfo& setPNext( const void* pNext_ )
+ ExportFenceCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExternalMemoryBufferCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+ ExportFenceCreateInfo& setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
}
- operator const VkExternalMemoryBufferCreateInfo&() const
+ operator VkExportFenceCreateInfo const&() const
{
- return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(this);
+ return *reinterpret_cast<const VkExportFenceCreateInfo*>(this);
}
- bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const
+ operator VkExportFenceCreateInfo &()
+ {
+ return *reinterpret_cast<VkExportFenceCreateInfo*>(this);
+ }
+
+ bool operator==( ExportFenceCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( handleTypes == rhs.handleTypes );
}
- bool operator!=( ExternalMemoryBufferCreateInfo const& rhs ) const
+ bool operator!=( ExportFenceCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
+ StructureType sType = StructureType::eExportFenceCreateInfo;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlags handleTypes;
+ ExternalFenceHandleTypeFlags handleTypes;
};
- static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
- using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
+ using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
- struct ExportMemoryAllocateInfo
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct FenceGetWin32HandleInfoKHR
{
- ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
+ ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : fence( fence_ )
+ , handleType( handleType_ )
{
}
- ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
+ FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+ memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
}
- ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
+ FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+ memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
return *this;
}
- ExportMemoryAllocateInfo& setPNext( const void* pNext_ )
+ FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExportMemoryAllocateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+ FenceGetWin32HandleInfoKHR& setFence( Fence fence_ )
{
- handleTypes = handleTypes_;
+ fence = fence_;
return *this;
}
- operator const VkExportMemoryAllocateInfo&() const
+ FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
{
- return *reinterpret_cast<const VkExportMemoryAllocateInfo*>(this);
+ handleType = handleType_;
+ return *this;
}
- bool operator==( ExportMemoryAllocateInfo const& rhs ) const
+ operator VkFenceGetWin32HandleInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this);
+ }
+
+ operator VkFenceGetWin32HandleInfoKHR &()
+ {
+ return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this);
+ }
+
+ bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ && ( fence == rhs.fence )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ExportMemoryAllocateInfo const& rhs ) const
+ bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExportMemoryAllocateInfo;
+ StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlags handleTypes;
+ Fence fence;
+ ExternalFenceHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
-
- using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
+ static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportMemoryWin32HandleInfoKHR
+ struct FenceGetFdInfoKHR
{
- ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
- HANDLE handle_ = 0,
- LPCWSTR name_ = 0 )
- : handleType( handleType_ )
- , handle( handle_ )
- , name( name_ )
+ FenceGetFdInfoKHR( Fence fence_ = Fence(),
+ ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : fence( fence_ )
+ , handleType( handleType_ )
{
}
- ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
+ FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
}
- ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
+ FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
return *this;
}
- ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
+ FenceGetFdInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ FenceGetFdInfoKHR& setFence( Fence fence_ )
{
- handleType = handleType_;
+ fence = fence_;
return *this;
}
- ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ )
+ FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
{
- handle = handle_;
+ handleType = handleType_;
return *this;
}
- ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
+ operator VkFenceGetFdInfoKHR const&() const
{
- name = name_;
- return *this;
+ return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this);
}
- operator const VkImportMemoryWin32HandleInfoKHR&() const
+ operator VkFenceGetFdInfoKHR &()
{
- return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this);
+ return *reinterpret_cast<VkFenceGetFdInfoKHR*>(this);
}
- bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
+ bool operator==( FenceGetFdInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleType == rhs.handleType )
- && ( handle == rhs.handle )
- && ( name == rhs.name );
+ && ( fence == rhs.fence )
+ && ( handleType == rhs.handleType );
}
- bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const
+ bool operator!=( FenceGetFdInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
+ StructureType sType = StructureType::eFenceGetFdInfoKHR;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
- HANDLE handle;
- LPCWSTR name;
+ Fence fence;
+ ExternalFenceHandleTypeFlagBits handleType;
};
- static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct MemoryGetWin32HandleInfoKHR
+ enum class ExternalFenceFeatureFlagBits
{
- MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
- ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : memory( memory_ )
- , handleType( handleType_ )
- {
- }
+ eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
+ eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
+ eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
+ eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
+ };
- MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
- }
+ using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits, VkExternalFenceFeatureFlags>;
- MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
- return *this;
- }
- MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
+ VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+ {
+ return ExternalFenceFeatureFlags( bit0 ) | bit1;
+ }
- MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ )
+ VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits )
+ {
+ return ~( ExternalFenceFeatureFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<ExternalFenceFeatureFlagBits>
+ {
+ enum
{
- memory = memory_;
- return *this;
- }
+ allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) | VkFlags(ExternalFenceFeatureFlagBits::eImportable)
+ };
+ };
- MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
+
+ struct ExternalFenceProperties
+ {
+ operator VkExternalFenceProperties const&() const
{
- handleType = handleType_;
- return *this;
+ return *reinterpret_cast<const VkExternalFenceProperties*>(this);
}
- operator const VkMemoryGetWin32HandleInfoKHR&() const
+ operator VkExternalFenceProperties &()
{
- return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this);
+ return *reinterpret_cast<VkExternalFenceProperties*>(this);
}
- bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
+ bool operator==( ExternalFenceProperties const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memory == rhs.memory )
- && ( handleType == rhs.handleType );
+ && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+ && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
+ && ( externalFenceFeatures == rhs.externalFenceFeatures );
}
- bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const
+ bool operator!=( ExternalFenceProperties const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
+ StructureType sType = StructureType::eExternalFenceProperties;
public:
- const void* pNext = nullptr;
- DeviceMemory memory;
- ExternalMemoryHandleTypeFlagBits handleType;
+ void* pNext = nullptr;
+ ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+ ExternalFenceHandleTypeFlags compatibleHandleTypes;
+ ExternalFenceFeatureFlags externalFenceFeatures;
};
- static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
- struct ImportMemoryFdInfoKHR
+ using ExternalFencePropertiesKHR = ExternalFenceProperties;
+
+ enum class FenceImportFlagBits
{
- ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
- int fd_ = 0 )
- : handleType( handleType_ )
- , fd( fd_ )
+ eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT,
+ eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT
+ };
+
+ using FenceImportFlags = Flags<FenceImportFlagBits, VkFenceImportFlags>;
+
+ VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ {
+ return FenceImportFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits )
+ {
+ return ~( FenceImportFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<FenceImportFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(FenceImportFlagBits::eTemporary)
+ };
+ };
+
+ using FenceImportFlagsKHR = FenceImportFlags;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ struct ImportFenceWin32HandleInfoKHR
+ {
+ ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
+ FenceImportFlags flags_ = FenceImportFlags(),
+ ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = 0 )
+ : fence( fence_ )
+ , flags( flags_ )
+ , handleType( handleType_ )
+ , handle( handle_ )
+ , name( name_ )
+ {
+ }
+
+ ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+ }
+
+ ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+ return *this;
+ }
+ ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
{
+ pNext = pNext_;
+ return *this;
}
- ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
+ ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ )
{
- memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
+ fence = fence_;
+ return *this;
}
- ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
+ ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlags flags_ )
{
- memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
+ flags = flags_;
return *this;
}
- ImportMemoryFdInfoKHR& setPNext( const void* pNext_ )
+
+ ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
{
- pNext = pNext_;
+ handleType = handleType_;
return *this;
}
- ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ )
{
- handleType = handleType_;
+ handle = handle_;
return *this;
}
- ImportMemoryFdInfoKHR& setFd( int fd_ )
+ ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
{
- fd = fd_;
+ name = name_;
return *this;
}
- operator const VkImportMemoryFdInfoKHR&() const
+ operator VkImportFenceWin32HandleInfoKHR const&() const
{
- return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this);
+ return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this);
}
- bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
+ operator VkImportFenceWin32HandleInfoKHR &()
+ {
+ return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this);
+ }
+
+ bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
+ && ( fence == rhs.fence )
+ && ( flags == rhs.flags )
&& ( handleType == rhs.handleType )
- && ( fd == rhs.fd );
+ && ( handle == rhs.handle )
+ && ( name == rhs.name );
}
- bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const
+ bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImportMemoryFdInfoKHR;
+ StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
- int fd;
+ Fence fence;
+ FenceImportFlags flags;
+ ExternalFenceHandleTypeFlagBits handleType;
+ HANDLE handle;
+ LPCWSTR name;
};
- static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct MemoryGetFdInfoKHR
+ struct ImportFenceFdInfoKHR
{
- MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(),
- ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : memory( memory_ )
+ ImportFenceFdInfoKHR( Fence fence_ = Fence(),
+ FenceImportFlags flags_ = FenceImportFlags(),
+ ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : fence( fence_ )
+ , flags( flags_ )
, handleType( handleType_ )
+ , fd( fd_ )
{
}
- MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
+ ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
}
- MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
+ ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
return *this;
}
- MemoryGetFdInfoKHR& setPNext( const void* pNext_ )
+ ImportFenceFdInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ )
+ ImportFenceFdInfoKHR& setFence( Fence fence_ )
{
- memory = memory_;
+ fence = fence_;
return *this;
}
- MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportFenceFdInfoKHR& setFlags( FenceImportFlags flags_ )
{
- handleType = handleType_;
+ flags = flags_;
return *this;
}
- operator const VkMemoryGetFdInfoKHR&() const
- {
- return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this);
- }
-
- bool operator==( MemoryGetFdInfoKHR const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( memory == rhs.memory )
- && ( handleType == rhs.handleType );
- }
-
- bool operator!=( MemoryGetFdInfoKHR const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- private:
- StructureType sType = StructureType::eMemoryGetFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- DeviceMemory memory;
- ExternalMemoryHandleTypeFlagBits handleType;
- };
- static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
-
- struct ImportMemoryHostPointerInfoEXT
- {
- ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
- void* pHostPointer_ = nullptr )
- : handleType( handleType_ )
- , pHostPointer( pHostPointer_ )
- {
- }
-
- ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
- }
-
- ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
- return *this;
- }
- ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ )
+ ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
{
- pNext = pNext_;
+ handleType = handleType_;
return *this;
}
- ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportFenceFdInfoKHR& setFd( int fd_ )
{
- handleType = handleType_;
+ fd = fd_;
return *this;
}
- ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ )
+ operator VkImportFenceFdInfoKHR const&() const
{
- pHostPointer = pHostPointer_;
- return *this;
+ return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this);
}
- operator const VkImportMemoryHostPointerInfoEXT&() const
+ operator VkImportFenceFdInfoKHR &()
{
- return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
+ return *reinterpret_cast<VkImportFenceFdInfoKHR*>(this);
}
- bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
+ bool operator==( ImportFenceFdInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
+ && ( fence == rhs.fence )
+ && ( flags == rhs.flags )
&& ( handleType == rhs.handleType )
- && ( pHostPointer == rhs.pHostPointer );
+ && ( fd == rhs.fd );
}
- bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const
+ bool operator!=( ImportFenceFdInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
+ StructureType sType = StructureType::eImportFenceFdInfoKHR;
public:
const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
- void* pHostPointer;
+ Fence fence;
+ FenceImportFlags flags;
+ ExternalFenceHandleTypeFlagBits handleType;
+ int fd;
};
- static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
- enum class ExternalMemoryFeatureFlagBits
+ enum class SurfaceCounterFlagBitsEXT
{
- eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
- eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
- eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
- eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
- eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
- eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
+ eVblank = VK_SURFACE_COUNTER_VBLANK_EXT
};
- using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits, VkExternalMemoryFeatureFlags>;
+ using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
{
- return ExternalMemoryFeatureFlags( bit0 ) | bit1;
+ return SurfaceCounterFlagsEXT( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits )
+ VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
{
- return ~( ExternalMemoryFeatureFlags( bits ) );
+ return ~( SurfaceCounterFlagsEXT( bits ) );
}
- template <> struct FlagTraits<ExternalMemoryFeatureFlagBits>
+ template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
{
enum
{
- allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBits::eExportable) | VkFlags(ExternalMemoryFeatureFlagBits::eImportable)
+ allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank)
};
};
- using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
-
- struct ExternalMemoryProperties
+ struct SurfaceCapabilities2EXT
{
- operator const VkExternalMemoryProperties&() const
+ operator VkSurfaceCapabilities2EXT const&() const
{
- return *reinterpret_cast<const VkExternalMemoryProperties*>(this);
+ return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
}
- bool operator==( ExternalMemoryProperties const& rhs ) const
+ operator VkSurfaceCapabilities2EXT &()
{
- return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
- && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
- && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+ return *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this);
}
- bool operator!=( ExternalMemoryProperties const& rhs ) const
+ bool operator==( SurfaceCapabilities2EXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( minImageCount == rhs.minImageCount )
+ && ( maxImageCount == rhs.maxImageCount )
+ && ( currentExtent == rhs.currentExtent )
+ && ( minImageExtent == rhs.minImageExtent )
+ && ( maxImageExtent == rhs.maxImageExtent )
+ && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+ && ( supportedTransforms == rhs.supportedTransforms )
+ && ( currentTransform == rhs.currentTransform )
+ && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
+ && ( supportedUsageFlags == rhs.supportedUsageFlags )
+ && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+ }
+
+ bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
{
return !operator==( rhs );
}
- ExternalMemoryFeatureFlags externalMemoryFeatures;
- ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
- ExternalMemoryHandleTypeFlags compatibleHandleTypes;
- };
- static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
+ private:
+ StructureType sType = StructureType::eSurfaceCapabilities2EXT;
- using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
+ public:
+ void* pNext = nullptr;
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ Extent2D currentExtent;
+ Extent2D minImageExtent;
+ Extent2D maxImageExtent;
+ uint32_t maxImageArrayLayers;
+ SurfaceTransformFlagsKHR supportedTransforms;
+ SurfaceTransformFlagBitsKHR currentTransform;
+ CompositeAlphaFlagsKHR supportedCompositeAlpha;
+ ImageUsageFlags supportedUsageFlags;
+ SurfaceCounterFlagsEXT supportedSurfaceCounters;
+ };
+ static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
- struct ExternalImageFormatProperties
+ struct SwapchainCounterCreateInfoEXT
{
- operator const VkExternalImageFormatProperties&() const
+ SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
+ : surfaceCounters( surfaceCounters_ )
{
- return *reinterpret_cast<const VkExternalImageFormatProperties*>(this);
}
- bool operator==( ExternalImageFormatProperties const& rhs ) const
+ SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( externalMemoryProperties == rhs.externalMemoryProperties );
+ memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
}
- bool operator!=( ExternalImageFormatProperties const& rhs ) const
+ SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
{
- return !operator==( rhs );
+ memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
+ return *this;
+ }
+ SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eExternalImageFormatProperties;
-
- public:
- void* pNext = nullptr;
- ExternalMemoryProperties externalMemoryProperties;
- };
- static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
+ SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
+ {
+ surfaceCounters = surfaceCounters_;
+ return *this;
+ }
- using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
+ operator VkSwapchainCounterCreateInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
+ }
- struct ExternalBufferProperties
- {
- operator const VkExternalBufferProperties&() const
+ operator VkSwapchainCounterCreateInfoEXT &()
{
- return *reinterpret_cast<const VkExternalBufferProperties*>(this);
+ return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this);
}
- bool operator==( ExternalBufferProperties const& rhs ) const
+ bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( externalMemoryProperties == rhs.externalMemoryProperties );
+ && ( surfaceCounters == rhs.surfaceCounters );
}
- bool operator!=( ExternalBufferProperties const& rhs ) const
+ bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExternalBufferProperties;
+ StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
public:
- void* pNext = nullptr;
- ExternalMemoryProperties externalMemoryProperties;
- };
- static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
-
- using ExternalBufferPropertiesKHR = ExternalBufferProperties;
-
- enum class ExternalSemaphoreHandleTypeFlagBits
- {
- eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
- eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
- eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
- eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
- eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
- eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
- eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
- eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
- eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
- eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ const void* pNext = nullptr;
+ SurfaceCounterFlagsEXT surfaceCounters;
};
+ static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
- using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreHandleTypeFlags>;
-
- VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
- {
- return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits )
- {
- return ~( ExternalSemaphoreHandleTypeFlags( bits ) );
- }
-
- template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits>
+ enum class DisplayPowerStateEXT
{
- enum
- {
- allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
- };
+ eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
+ eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
+ eOn = VK_DISPLAY_POWER_STATE_ON_EXT
};
- using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
-
- struct PhysicalDeviceExternalSemaphoreInfo
+ struct DisplayPowerInfoEXT
{
- PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
- : handleType( handleType_ )
+ DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
+ : powerState( powerState_ )
{
}
- PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
+ DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
+ memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
}
- PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
+ DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
+ memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
return *this;
}
- PhysicalDeviceExternalSemaphoreInfo& setPNext( const void* pNext_ )
+ DisplayPowerInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceExternalSemaphoreInfo& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ )
{
- handleType = handleType_;
+ powerState = powerState_;
return *this;
}
- operator const VkPhysicalDeviceExternalSemaphoreInfo&() const
+ operator VkDisplayPowerInfoEXT const&() const
{
- return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(this);
+ return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
}
- bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
+ operator VkDisplayPowerInfoEXT &()
+ {
+ return *reinterpret_cast<VkDisplayPowerInfoEXT*>(this);
+ }
+
+ bool operator==( DisplayPowerInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleType == rhs.handleType );
+ && ( powerState == rhs.powerState );
}
- bool operator!=( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
+ bool operator!=( DisplayPowerInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
+ StructureType sType = StructureType::eDisplayPowerInfoEXT;
public:
const void* pNext = nullptr;
- ExternalSemaphoreHandleTypeFlagBits handleType;
+ DisplayPowerStateEXT powerState;
};
- static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
- using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
+ enum class DeviceEventTypeEXT
+ {
+ eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
+ };
- struct ExportSemaphoreCreateInfo
+ struct DeviceEventInfoEXT
{
- ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
+ : deviceEvent( deviceEvent_ )
{
}
- ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
+ DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
}
- ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
+ DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
return *this;
}
- ExportSemaphoreCreateInfo& setPNext( const void* pNext_ )
+ DeviceEventInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ExportSemaphoreCreateInfo& setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ )
+ DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
{
- handleTypes = handleTypes_;
+ deviceEvent = deviceEvent_;
return *this;
}
- operator const VkExportSemaphoreCreateInfo&() const
+ operator VkDeviceEventInfoEXT const&() const
{
- return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>(this);
+ return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
}
- bool operator==( ExportSemaphoreCreateInfo const& rhs ) const
+ operator VkDeviceEventInfoEXT &()
+ {
+ return *reinterpret_cast<VkDeviceEventInfoEXT*>(this);
+ }
+
+ bool operator==( DeviceEventInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ && ( deviceEvent == rhs.deviceEvent );
}
- bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const
+ bool operator!=( DeviceEventInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExportSemaphoreCreateInfo;
+ StructureType sType = StructureType::eDeviceEventInfoEXT;
public:
const void* pNext = nullptr;
- ExternalSemaphoreHandleTypeFlags handleTypes;
+ DeviceEventTypeEXT deviceEvent;
};
- static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
- using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
+ enum class DisplayEventTypeEXT
+ {
+ eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
+ };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct SemaphoreGetWin32HandleInfoKHR
+ struct DisplayEventInfoEXT
{
- SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
- : semaphore( semaphore_ )
- , handleType( handleType_ )
+ DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
+ : displayEvent( displayEvent_ )
{
}
- SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+ DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
}
- SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+ DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
return *this;
}
- SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
+ DisplayEventInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
+ DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
{
- semaphore = semaphore_;
+ displayEvent = displayEvent_;
return *this;
}
- SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ operator VkDisplayEventInfoEXT const&() const
{
- handleType = handleType_;
- return *this;
+ return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
}
- operator const VkSemaphoreGetWin32HandleInfoKHR&() const
+ operator VkDisplayEventInfoEXT &()
{
- return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this);
+ return *reinterpret_cast<VkDisplayEventInfoEXT*>(this);
}
- bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
+ bool operator==( DisplayEventInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( semaphore == rhs.semaphore )
- && ( handleType == rhs.handleType );
+ && ( displayEvent == rhs.displayEvent );
}
- bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
+ bool operator!=( DisplayEventInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+ StructureType sType = StructureType::eDisplayEventInfoEXT;
public:
const void* pNext = nullptr;
- Semaphore semaphore;
- ExternalSemaphoreHandleTypeFlagBits handleType;
+ DisplayEventTypeEXT displayEvent;
+ };
+ static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
+
+ enum class PeerMemoryFeatureFlagBits
+ {
+ eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
+ eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
+ eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
+ eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
+ eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
+ eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
+ eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
+ eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
+ };
+
+ using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits, VkPeerMemoryFeatureFlags>;
+
+ VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+ {
+ return PeerMemoryFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits )
+ {
+ return ~( PeerMemoryFeatureFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<PeerMemoryFeatureFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBits::eGenericDst)
+ };
+ };
+
+ using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
+
+ enum class MemoryAllocateFlagBits
+ {
+ eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
+ eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
+ };
+
+ using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits, VkMemoryAllocateFlags>;
+
+ VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+ {
+ return MemoryAllocateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits )
+ {
+ return ~( MemoryAllocateFlags( bits ) );
+ }
+
+ template <> struct FlagTraits<MemoryAllocateFlagBits>
+ {
+ enum
+ {
+ allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask)
+ };
};
- static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct SemaphoreGetFdInfoKHR
+ using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
+
+ struct MemoryAllocateFlagsInfo
{
- SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
- : semaphore( semaphore_ )
- , handleType( handleType_ )
+ MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(),
+ uint32_t deviceMask_ = 0 )
+ : flags( flags_ )
+ , deviceMask( deviceMask_ )
{
}
- SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
+ MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
}
- SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
+ MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
return *this;
}
- SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ )
+ MemoryAllocateFlagsInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ )
+ MemoryAllocateFlagsInfo& setFlags( MemoryAllocateFlags flags_ )
{
- semaphore = semaphore_;
+ flags = flags_;
return *this;
}
- SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ MemoryAllocateFlagsInfo& setDeviceMask( uint32_t deviceMask_ )
{
- handleType = handleType_;
+ deviceMask = deviceMask_;
return *this;
}
- operator const VkSemaphoreGetFdInfoKHR&() const
+ operator VkMemoryAllocateFlagsInfo const&() const
{
- return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this);
+ return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(this);
}
- bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
+ operator VkMemoryAllocateFlagsInfo &()
+ {
+ return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this);
+ }
+
+ bool operator==( MemoryAllocateFlagsInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( semaphore == rhs.semaphore )
- && ( handleType == rhs.handleType );
+ && ( flags == rhs.flags )
+ && ( deviceMask == rhs.deviceMask );
}
- bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const
+ bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
+ StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
public:
const void* pNext = nullptr;
- Semaphore semaphore;
- ExternalSemaphoreHandleTypeFlagBits handleType;
+ MemoryAllocateFlags flags;
+ uint32_t deviceMask;
};
- static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
- enum class ExternalSemaphoreFeatureFlagBits
+ using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
+
+ enum class DeviceGroupPresentModeFlagBitsKHR
{
- eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
- eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
- eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
- eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
+ eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR,
+ eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR,
+ eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR,
+ eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
};
- using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits, VkExternalSemaphoreFeatureFlags>;
+ using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR, VkDeviceGroupPresentModeFlagsKHR>;
- VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+ VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
{
- return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
+ return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits )
+ VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits )
{
- return ~( ExternalSemaphoreFeatureFlags( bits ) );
+ return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
}
- template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits>
+ template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR>
{
enum
{
- allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable)
+ allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
};
};
- using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
-
- struct ExternalSemaphoreProperties
+ struct DeviceGroupPresentCapabilitiesKHR
{
- operator const VkExternalSemaphoreProperties&() const
+ operator VkDeviceGroupPresentCapabilitiesKHR const&() const
{
- return *reinterpret_cast<const VkExternalSemaphoreProperties*>(this);
+ return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(this);
}
- bool operator==( ExternalSemaphoreProperties const& rhs ) const
+ operator VkDeviceGroupPresentCapabilitiesKHR &()
+ {
+ return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this);
+ }
+
+ bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
- && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
- && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
+ && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 )
+ && ( modes == rhs.modes );
}
- bool operator!=( ExternalSemaphoreProperties const& rhs ) const
+ bool operator!=( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExternalSemaphoreProperties;
+ StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
public:
- void* pNext = nullptr;
- ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
- ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
- ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
- };
- static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
-
- using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
-
- enum class SemaphoreImportFlagBits
- {
- eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
- eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
- };
-
- using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits, VkSemaphoreImportFlags>;
-
- VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
- {
- return SemaphoreImportFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits )
- {
- return ~( SemaphoreImportFlags( bits ) );
- }
-
- template <> struct FlagTraits<SemaphoreImportFlagBits>
- {
- enum
- {
- allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary)
- };
+ const void* pNext = nullptr;
+ uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+ DeviceGroupPresentModeFlagsKHR modes;
};
+ static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
- using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportSemaphoreWin32HandleInfoKHR
+ struct DeviceGroupPresentInfoKHR
{
- ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
- SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
- HANDLE handle_ = 0,
- LPCWSTR name_ = 0 )
- : semaphore( semaphore_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , handle( handle_ )
- , name( name_ )
+ DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
+ const uint32_t* pDeviceMasks_ = nullptr,
+ DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal )
+ : swapchainCount( swapchainCount_ )
+ , pDeviceMasks( pDeviceMasks_ )
+ , mode( mode_ )
{
}
- ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+ DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
}
- ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+ DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
+ DeviceGroupPresentInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
- {
- semaphore = semaphore_;
- return *this;
- }
-
- ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlags flags_ )
+ DeviceGroupPresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
{
- flags = flags_;
+ swapchainCount = swapchainCount_;
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ DeviceGroupPresentInfoKHR& setPDeviceMasks( const uint32_t* pDeviceMasks_ )
{
- handleType = handleType_;
+ pDeviceMasks = pDeviceMasks_;
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ )
+ DeviceGroupPresentInfoKHR& setMode( DeviceGroupPresentModeFlagBitsKHR mode_ )
{
- handle = handle_;
+ mode = mode_;
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
+ operator VkDeviceGroupPresentInfoKHR const&() const
{
- name = name_;
- return *this;
+ return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(this);
}
- operator const VkImportSemaphoreWin32HandleInfoKHR&() const
+ operator VkDeviceGroupPresentInfoKHR &()
{
- return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this);
+ return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this);
}
- bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
+ bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( semaphore == rhs.semaphore )
- && ( flags == rhs.flags )
- && ( handleType == rhs.handleType )
- && ( handle == rhs.handle )
- && ( name == rhs.name );
+ && ( swapchainCount == rhs.swapchainCount )
+ && ( pDeviceMasks == rhs.pDeviceMasks )
+ && ( mode == rhs.mode );
}
- bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
+ bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
+ StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
public:
const void* pNext = nullptr;
- Semaphore semaphore;
- SemaphoreImportFlags flags;
- ExternalSemaphoreHandleTypeFlagBits handleType;
- HANDLE handle;
- LPCWSTR name;
+ uint32_t swapchainCount;
+ const uint32_t* pDeviceMasks;
+ DeviceGroupPresentModeFlagBitsKHR mode;
};
- static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
- struct ImportSemaphoreFdInfoKHR
+ struct DeviceGroupSwapchainCreateInfoKHR
{
- ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(),
- SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
- int fd_ = 0 )
- : semaphore( semaphore_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , fd( fd_ )
+ DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() )
+ : modes( modes_ )
{
}
- ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
+ DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
}
- ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
+ DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
return *this;
}
- ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ )
+ DeviceGroupSwapchainCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ )
- {
- semaphore = semaphore_;
- return *this;
- }
-
- ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ DeviceGroupSwapchainCreateInfoKHR& setModes( DeviceGroupPresentModeFlagsKHR modes_ )
{
- handleType = handleType_;
+ modes = modes_;
return *this;
}
- ImportSemaphoreFdInfoKHR& setFd( int fd_ )
+ operator VkDeviceGroupSwapchainCreateInfoKHR const&() const
{
- fd = fd_;
- return *this;
+ return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(this);
}
- operator const VkImportSemaphoreFdInfoKHR&() const
+ operator VkDeviceGroupSwapchainCreateInfoKHR &()
{
- return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this);
+ return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this);
}
- bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
+ bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( semaphore == rhs.semaphore )
- && ( flags == rhs.flags )
- && ( handleType == rhs.handleType )
- && ( fd == rhs.fd );
+ && ( modes == rhs.modes );
}
- bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const
+ bool operator!=( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
+ StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
public:
const void* pNext = nullptr;
- Semaphore semaphore;
- SemaphoreImportFlags flags;
- ExternalSemaphoreHandleTypeFlagBits handleType;
- int fd;
+ DeviceGroupPresentModeFlagsKHR modes;
};
- static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
- enum class ExternalFenceHandleTypeFlagBits
+ enum class SwapchainCreateFlagBitsKHR
{
- eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
- eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
- eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
- eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
- eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
- eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
- eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
- eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR,
+ eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR
};
- using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits, VkExternalFenceHandleTypeFlags>;
+ using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
- VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+ VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
{
- return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
+ return SwapchainCreateFlagsKHR( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits )
+ VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
{
- return ~( ExternalFenceHandleTypeFlags( bits ) );
+ return ~( SwapchainCreateFlagsKHR( bits ) );
}
- template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits>
+ template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
{
enum
{
- allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd)
+ allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected)
};
};
- using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
-
- struct PhysicalDeviceExternalFenceInfo
+ struct SwapchainCreateInfoKHR
{
- PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
- : handleType( handleType_ )
+ SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(),
+ SurfaceKHR surface_ = SurfaceKHR(),
+ uint32_t minImageCount_ = 0,
+ Format imageFormat_ = Format::eUndefined,
+ ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear,
+ Extent2D imageExtent_ = Extent2D(),
+ uint32_t imageArrayLayers_ = 0,
+ ImageUsageFlags imageUsage_ = ImageUsageFlags(),
+ SharingMode imageSharingMode_ = SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr,
+ SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity,
+ CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque,
+ PresentModeKHR presentMode_ = PresentModeKHR::eImmediate,
+ Bool32 clipped_ = 0,
+ SwapchainKHR oldSwapchain_ = SwapchainKHR() )
+ : flags( flags_ )
+ , surface( surface_ )
+ , minImageCount( minImageCount_ )
+ , imageFormat( imageFormat_ )
+ , imageColorSpace( imageColorSpace_ )
+ , imageExtent( imageExtent_ )
+ , imageArrayLayers( imageArrayLayers_ )
+ , imageUsage( imageUsage_ )
+ , imageSharingMode( imageSharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , preTransform( preTransform_ )
+ , compositeAlpha( compositeAlpha_ )
+ , presentMode( presentMode_ )
+ , clipped( clipped_ )
+ , oldSwapchain( oldSwapchain_ )
{
}
- PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
+ SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
+ memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
}
- PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
+ SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
+ memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
return *this;
}
- PhysicalDeviceExternalFenceInfo& setPNext( const void* pNext_ )
+ SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceExternalFenceInfo& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
{
- handleType = handleType_;
+ flags = flags_;
return *this;
}
- operator const VkPhysicalDeviceExternalFenceInfo&() const
+ SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
{
- return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(this);
+ surface = surface_;
+ return *this;
}
- bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const
+ SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
+ {
+ minImageCount = minImageCount_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
+ {
+ imageFormat = imageFormat_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
+ {
+ imageColorSpace = imageColorSpace_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ {
+ imageExtent = imageExtent_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
+ {
+ imageArrayLayers = imageArrayLayers_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
+ {
+ imageUsage = imageUsage_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
+ {
+ imageSharingMode = imageSharingMode_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ {
+ queueFamilyIndexCount = queueFamilyIndexCount_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ {
+ pQueueFamilyIndices = pQueueFamilyIndices_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
+ {
+ preTransform = preTransform_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
+ {
+ compositeAlpha = compositeAlpha_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
+ {
+ presentMode = presentMode_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
+ {
+ clipped = clipped_;
+ return *this;
+ }
+
+ SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
+ {
+ oldSwapchain = oldSwapchain_;
+ return *this;
+ }
+
+ operator VkSwapchainCreateInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
+ }
+
+ operator VkSwapchainCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this);
+ }
+
+ bool operator==( SwapchainCreateInfoKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( handleType == rhs.handleType );
+ && ( flags == rhs.flags )
+ && ( surface == rhs.surface )
+ && ( minImageCount == rhs.minImageCount )
+ && ( imageFormat == rhs.imageFormat )
+ && ( imageColorSpace == rhs.imageColorSpace )
+ && ( imageExtent == rhs.imageExtent )
+ && ( imageArrayLayers == rhs.imageArrayLayers )
+ && ( imageUsage == rhs.imageUsage )
+ && ( imageSharingMode == rhs.imageSharingMode )
+ && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+ && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
+ && ( preTransform == rhs.preTransform )
+ && ( compositeAlpha == rhs.compositeAlpha )
+ && ( presentMode == rhs.presentMode )
+ && ( clipped == rhs.clipped )
+ && ( oldSwapchain == rhs.oldSwapchain );
}
- bool operator!=( PhysicalDeviceExternalFenceInfo const& rhs ) const
+ bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
+ StructureType sType = StructureType::eSwapchainCreateInfoKHR;
public:
const void* pNext = nullptr;
- ExternalFenceHandleTypeFlagBits handleType;
+ SwapchainCreateFlagsKHR flags;
+ SurfaceKHR surface;
+ uint32_t minImageCount;
+ Format imageFormat;
+ ColorSpaceKHR imageColorSpace;
+ Extent2D imageExtent;
+ uint32_t imageArrayLayers;
+ ImageUsageFlags imageUsage;
+ SharingMode imageSharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ SurfaceTransformFlagBitsKHR preTransform;
+ CompositeAlphaFlagBitsKHR compositeAlpha;
+ PresentModeKHR presentMode;
+ Bool32 clipped;
+ SwapchainKHR oldSwapchain;
};
- static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
- using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
+ enum class ViewportCoordinateSwizzleNV
+ {
+ ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
+ eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
+ ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
+ eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
+ ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
+ eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
+ ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
+ eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+ };
+
+ struct ViewportSwizzleNV
+ {
+ ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX,
+ ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX,
+ ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX,
+ ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX )
+ : x( x_ )
+ , y( y_ )
+ , z( z_ )
+ , w( w_ )
+ {
+ }
- struct ExportFenceCreateInfo
- {
- ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
{
+ memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
}
- ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
+ ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
+ return *this;
+ }
+ ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ )
+ {
+ x = x_;
+ return *this;
}
- ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
+ ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ )
{
- memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
+ y = y_;
return *this;
}
- ExportFenceCreateInfo& setPNext( const void* pNext_ )
+
+ ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ )
{
- pNext = pNext_;
+ z = z_;
return *this;
}
- ExportFenceCreateInfo& setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ )
+ ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ )
{
- handleTypes = handleTypes_;
+ w = w_;
return *this;
}
- operator const VkExportFenceCreateInfo&() const
+ operator VkViewportSwizzleNV const&() const
{
- return *reinterpret_cast<const VkExportFenceCreateInfo*>(this);
+ return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
}
- bool operator==( ExportFenceCreateInfo const& rhs ) const
+ operator VkViewportSwizzleNV &()
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( handleTypes == rhs.handleTypes );
+ return *reinterpret_cast<VkViewportSwizzleNV*>(this);
}
- bool operator!=( ExportFenceCreateInfo const& rhs ) const
+ bool operator==( ViewportSwizzleNV const& rhs ) const
{
- return !operator==( rhs );
+ return ( x == rhs.x )
+ && ( y == rhs.y )
+ && ( z == rhs.z )
+ && ( w == rhs.w );
}
- private:
- StructureType sType = StructureType::eExportFenceCreateInfo;
+ bool operator!=( ViewportSwizzleNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
- public:
- const void* pNext = nullptr;
- ExternalFenceHandleTypeFlags handleTypes;
+ ViewportCoordinateSwizzleNV x;
+ ViewportCoordinateSwizzleNV y;
+ ViewportCoordinateSwizzleNV z;
+ ViewportCoordinateSwizzleNV w;
};
- static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
-
- using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
+ static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct FenceGetWin32HandleInfoKHR
+ struct PipelineViewportSwizzleStateCreateInfoNV
{
- FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
- : fence( fence_ )
- , handleType( handleType_ )
+ PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(),
+ uint32_t viewportCount_ = 0,
+ const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
+ : flags( flags_ )
+ , viewportCount( viewportCount_ )
+ , pViewportSwizzles( pViewportSwizzles_ )
{
}
- FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
+ PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
}
- FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
+ PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
return *this;
}
- FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
+ PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- FenceGetWin32HandleInfoKHR& setFence( Fence fence_ )
+ PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
{
- fence = fence_;
+ flags = flags_;
return *this;
}
- FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
{
- handleType = handleType_;
+ viewportCount = viewportCount_;
return *this;
}
- operator const VkFenceGetWin32HandleInfoKHR&() const
+ PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
{
- return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this);
+ pViewportSwizzles = pViewportSwizzles_;
+ return *this;
}
- bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
+ operator VkPipelineViewportSwizzleStateCreateInfoNV const&() const
+ {
+ return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+ }
+
+ operator VkPipelineViewportSwizzleStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+ }
+
+ bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( fence == rhs.fence )
- && ( handleType == rhs.handleType );
+ && ( flags == rhs.flags )
+ && ( viewportCount == rhs.viewportCount )
+ && ( pViewportSwizzles == rhs.pViewportSwizzles );
}
- bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const
+ bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
+ StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
public:
const void* pNext = nullptr;
- Fence fence;
- ExternalFenceHandleTypeFlagBits handleType;
+ PipelineViewportSwizzleStateCreateFlagsNV flags;
+ uint32_t viewportCount;
+ const ViewportSwizzleNV* pViewportSwizzles;
};
- static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
- struct FenceGetFdInfoKHR
+ enum class DiscardRectangleModeEXT
{
- FenceGetFdInfoKHR( Fence fence_ = Fence(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
- : fence( fence_ )
- , handleType( handleType_ )
+ eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
+ eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
+ };
+
+ struct PipelineDiscardRectangleStateCreateInfoEXT
+ {
+ PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(),
+ DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive,
+ uint32_t discardRectangleCount_ = 0,
+ const Rect2D* pDiscardRectangles_ = nullptr )
+ : flags( flags_ )
+ , discardRectangleMode( discardRectangleMode_ )
+ , discardRectangleCount( discardRectangleCount_ )
+ , pDiscardRectangles( pDiscardRectangles_ )
{
}
- FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
+ PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
}
- FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
+ PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
return *this;
}
- FenceGetFdInfoKHR& setPNext( const void* pNext_ )
+ PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- FenceGetFdInfoKHR& setFence( Fence fence_ )
+ PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
{
- fence = fence_;
+ flags = flags_;
return *this;
}
- FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
{
- handleType = handleType_;
+ discardRectangleMode = discardRectangleMode_;
return *this;
}
- operator const VkFenceGetFdInfoKHR&() const
+ PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ )
{
- return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this);
+ discardRectangleCount = discardRectangleCount_;
+ return *this;
}
- bool operator==( FenceGetFdInfoKHR const& rhs ) const
+ PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( fence == rhs.fence )
- && ( handleType == rhs.handleType );
+ pDiscardRectangles = pDiscardRectangles_;
+ return *this;
}
- bool operator!=( FenceGetFdInfoKHR const& rhs ) const
+ operator VkPipelineDiscardRectangleStateCreateInfoEXT const&() const
{
- return !operator==( rhs );
+ return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
}
- private:
- StructureType sType = StructureType::eFenceGetFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- ExternalFenceHandleTypeFlagBits handleType;
- };
- static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
-
- enum class ExternalFenceFeatureFlagBits
- {
- eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
- eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
- eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
- eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
- };
-
- using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits, VkExternalFenceFeatureFlags>;
-
- VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
- {
- return ExternalFenceFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits )
- {
- return ~( ExternalFenceFeatureFlags( bits ) );
- }
-
- template <> struct FlagTraits<ExternalFenceFeatureFlagBits>
- {
- enum
- {
- allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) | VkFlags(ExternalFenceFeatureFlagBits::eImportable)
- };
- };
-
- using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
-
- struct ExternalFenceProperties
- {
- operator const VkExternalFenceProperties&() const
+ operator VkPipelineDiscardRectangleStateCreateInfoEXT &()
{
- return *reinterpret_cast<const VkExternalFenceProperties*>(this);
+ return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
}
- bool operator==( ExternalFenceProperties const& rhs ) const
+ bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
- && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
- && ( externalFenceFeatures == rhs.externalFenceFeatures );
+ && ( flags == rhs.flags )
+ && ( discardRectangleMode == rhs.discardRectangleMode )
+ && ( discardRectangleCount == rhs.discardRectangleCount )
+ && ( pDiscardRectangles == rhs.pDiscardRectangles );
}
- bool operator!=( ExternalFenceProperties const& rhs ) const
+ bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eExternalFenceProperties;
+ StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
public:
- void* pNext = nullptr;
- ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
- ExternalFenceHandleTypeFlags compatibleHandleTypes;
- ExternalFenceFeatureFlags externalFenceFeatures;
+ const void* pNext = nullptr;
+ PipelineDiscardRectangleStateCreateFlagsEXT flags;
+ DiscardRectangleModeEXT discardRectangleMode;
+ uint32_t discardRectangleCount;
+ const Rect2D* pDiscardRectangles;
};
- static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
-
- using ExternalFencePropertiesKHR = ExternalFenceProperties;
+ static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
- enum class FenceImportFlagBits
+ enum class SubpassDescriptionFlagBits
{
- eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT,
- eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT
+ ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
+ ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
};
- using FenceImportFlags = Flags<FenceImportFlagBits, VkFenceImportFlags>;
+ using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
- VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
{
- return FenceImportFlags( bit0 ) | bit1;
+ return SubpassDescriptionFlags( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits )
+ VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
{
- return ~( FenceImportFlags( bits ) );
+ return ~( SubpassDescriptionFlags( bits ) );
}
- template <> struct FlagTraits<FenceImportFlagBits>
+ template <> struct FlagTraits<SubpassDescriptionFlagBits>
{
enum
{
- allFlags = VkFlags(FenceImportFlagBits::eTemporary)
+ allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
};
};
- using FenceImportFlagsKHR = FenceImportFlags;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportFenceWin32HandleInfoKHR
+ struct SubpassDescription
{
- ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
- FenceImportFlags flags_ = FenceImportFlags(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
- HANDLE handle_ = 0,
- LPCWSTR name_ = 0 )
- : fence( fence_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , handle( handle_ )
- , name( name_ )
+ SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
+ PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+ uint32_t inputAttachmentCount_ = 0,
+ const AttachmentReference* pInputAttachments_ = nullptr,
+ uint32_t colorAttachmentCount_ = 0,
+ const AttachmentReference* pColorAttachments_ = nullptr,
+ const AttachmentReference* pResolveAttachments_ = nullptr,
+ const AttachmentReference* pDepthStencilAttachment_ = nullptr,
+ uint32_t preserveAttachmentCount_ = 0,
+ const uint32_t* pPreserveAttachments_ = nullptr )
+ : flags( flags_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , inputAttachmentCount( inputAttachmentCount_ )
+ , pInputAttachments( pInputAttachments_ )
+ , colorAttachmentCount( colorAttachmentCount_ )
+ , pColorAttachments( pColorAttachments_ )
+ , pResolveAttachments( pResolveAttachments_ )
+ , pDepthStencilAttachment( pDepthStencilAttachment_ )
+ , preserveAttachmentCount( preserveAttachmentCount_ )
+ , pPreserveAttachments( pPreserveAttachments_ )
{
}
- ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
+ SubpassDescription( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( SubpassDescription ) );
}
- ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
+ SubpassDescription& operator=( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+ memcpy( this, &rhs, sizeof( SubpassDescription ) );
return *this;
}
- ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
+ SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
{
- pNext = pNext_;
+ flags = flags_;
return *this;
}
- ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ )
+ SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- fence = fence_;
+ pipelineBindPoint = pipelineBindPoint_;
return *this;
}
- ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlags flags_ )
+ SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
{
- flags = flags_;
+ inputAttachmentCount = inputAttachmentCount_;
return *this;
}
- ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
{
- handleType = handleType_;
+ pInputAttachments = pInputAttachments_;
return *this;
}
- ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ )
+ SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
{
- handle = handle_;
+ colorAttachmentCount = colorAttachmentCount_;
return *this;
}
- ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
+ SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
{
- name = name_;
+ pColorAttachments = pColorAttachments_;
return *this;
}
- operator const VkImportFenceWin32HandleInfoKHR&() const
- {
- return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this);
- }
-
- bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( fence == rhs.fence )
- && ( flags == rhs.flags )
- && ( handleType == rhs.handleType )
- && ( handle == rhs.handle )
- && ( name == rhs.name );
- }
-
- bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- private:
- StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- FenceImportFlags flags;
- ExternalFenceHandleTypeFlagBits handleType;
- HANDLE handle;
- LPCWSTR name;
- };
- static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- struct ImportFenceFdInfoKHR
- {
- ImportFenceFdInfoKHR( Fence fence_ = Fence(),
- FenceImportFlags flags_ = FenceImportFlags(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
- int fd_ = 0 )
- : fence( fence_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , fd( fd_ )
- {
- }
-
- ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
- }
-
- ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
- return *this;
- }
- ImportFenceFdInfoKHR& setPNext( const void* pNext_ )
+ SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
{
- pNext = pNext_;
+ pResolveAttachments = pResolveAttachments_;
return *this;
}
- ImportFenceFdInfoKHR& setFence( Fence fence_ )
+ SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
{
- fence = fence_;
+ pDepthStencilAttachment = pDepthStencilAttachment_;
return *this;
}
- ImportFenceFdInfoKHR& setFlags( FenceImportFlags flags_ )
+ SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
{
- flags = flags_;
+ preserveAttachmentCount = preserveAttachmentCount_;
return *this;
}
- ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
{
- handleType = handleType_;
+ pPreserveAttachments = pPreserveAttachments_;
return *this;
}
- ImportFenceFdInfoKHR& setFd( int fd_ )
+ operator VkSubpassDescription const&() const
{
- fd = fd_;
- return *this;
+ return *reinterpret_cast<const VkSubpassDescription*>(this);
}
- operator const VkImportFenceFdInfoKHR&() const
+ operator VkSubpassDescription &()
{
- return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this);
+ return *reinterpret_cast<VkSubpassDescription*>(this);
}
- bool operator==( ImportFenceFdInfoKHR const& rhs ) const
+ bool operator==( SubpassDescription const& rhs ) const
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( fence == rhs.fence )
- && ( flags == rhs.flags )
- && ( handleType == rhs.handleType )
- && ( fd == rhs.fd );
+ return ( flags == rhs.flags )
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( inputAttachmentCount == rhs.inputAttachmentCount )
+ && ( pInputAttachments == rhs.pInputAttachments )
+ && ( colorAttachmentCount == rhs.colorAttachmentCount )
+ && ( pColorAttachments == rhs.pColorAttachments )
+ && ( pResolveAttachments == rhs.pResolveAttachments )
+ && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
+ && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
+ && ( pPreserveAttachments == rhs.pPreserveAttachments );
}
- bool operator!=( ImportFenceFdInfoKHR const& rhs ) const
+ bool operator!=( SubpassDescription const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType = StructureType::eImportFenceFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- FenceImportFlags flags;
- ExternalFenceHandleTypeFlagBits handleType;
- int fd;
- };
- static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
-
- enum class SurfaceCounterFlagBitsEXT
- {
- eVblank = VK_SURFACE_COUNTER_VBLANK_EXT
+ SubpassDescriptionFlags flags;
+ PipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+ const AttachmentReference* pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const AttachmentReference* pColorAttachments;
+ const AttachmentReference* pResolveAttachments;
+ const AttachmentReference* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t* pPreserveAttachments;
};
+ static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
- using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
-
- VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
- {
- return SurfaceCounterFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
- {
- return ~( SurfaceCounterFlagsEXT( bits ) );
- }
-
- template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
+ struct RenderPassCreateInfo
{
- enum
+ RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
+ uint32_t attachmentCount_ = 0,
+ const AttachmentDescription* pAttachments_ = nullptr,
+ uint32_t subpassCount_ = 0,
+ const SubpassDescription* pSubpasses_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const SubpassDependency* pDependencies_ = nullptr )
+ : flags( flags_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , subpassCount( subpassCount_ )
+ , pSubpasses( pSubpasses_ )
+ , dependencyCount( dependencyCount_ )
+ , pDependencies( pDependencies_ )
{
- allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank)
- };
- };
+ }
- struct SurfaceCapabilities2EXT
- {
- operator const VkSurfaceCapabilities2EXT&() const
+ RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
{
- return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
+ memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
}
- bool operator==( SurfaceCapabilities2EXT const& rhs ) const
+ RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( minImageCount == rhs.minImageCount )
- && ( maxImageCount == rhs.maxImageCount )
- && ( currentExtent == rhs.currentExtent )
- && ( minImageExtent == rhs.minImageExtent )
- && ( maxImageExtent == rhs.maxImageExtent )
- && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
- && ( supportedTransforms == rhs.supportedTransforms )
- && ( currentTransform == rhs.currentTransform )
- && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
- && ( supportedUsageFlags == rhs.supportedUsageFlags )
- && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+ memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
+ return *this;
+ }
+ RenderPassCreateInfo& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
}
- bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
+ RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
{
- return !operator==( rhs );
+ flags = flags_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eSurfaceCapabilities2EXT;
-
- public:
- void* pNext = nullptr;
- uint32_t minImageCount;
- uint32_t maxImageCount;
- Extent2D currentExtent;
- Extent2D minImageExtent;
- Extent2D maxImageExtent;
- uint32_t maxImageArrayLayers;
- SurfaceTransformFlagsKHR supportedTransforms;
- SurfaceTransformFlagBitsKHR currentTransform;
- CompositeAlphaFlagsKHR supportedCompositeAlpha;
- ImageUsageFlags supportedUsageFlags;
- SurfaceCounterFlagsEXT supportedSurfaceCounters;
- };
- static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
+ RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
+ {
+ attachmentCount = attachmentCount_;
+ return *this;
+ }
- struct SwapchainCounterCreateInfoEXT
- {
- SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
- : surfaceCounters( surfaceCounters_ )
+ RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
{
+ pAttachments = pAttachments_;
+ return *this;
}
- SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
+ RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
{
- memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
+ subpassCount = subpassCount_;
+ return *this;
}
- SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
+ RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
{
- memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
+ pSubpasses = pSubpasses_;
return *this;
}
- SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
+
+ RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
{
- pNext = pNext_;
+ dependencyCount = dependencyCount_;
return *this;
}
- SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
+ RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
{
- surfaceCounters = surfaceCounters_;
+ pDependencies = pDependencies_;
return *this;
}
- operator const VkSwapchainCounterCreateInfoEXT&() const
+ operator VkRenderPassCreateInfo const&() const
{
- return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
+ return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
}
- bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
+ operator VkRenderPassCreateInfo &()
+ {
+ return *reinterpret_cast<VkRenderPassCreateInfo*>(this);
+ }
+
+ bool operator==( RenderPassCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( surfaceCounters == rhs.surfaceCounters );
+ && ( flags == rhs.flags )
+ && ( attachmentCount == rhs.attachmentCount )
+ && ( pAttachments == rhs.pAttachments )
+ && ( subpassCount == rhs.subpassCount )
+ && ( pSubpasses == rhs.pSubpasses )
+ && ( dependencyCount == rhs.dependencyCount )
+ && ( pDependencies == rhs.pDependencies );
}
- bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
+ bool operator!=( RenderPassCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
+ StructureType sType = StructureType::eRenderPassCreateInfo;
public:
const void* pNext = nullptr;
- SurfaceCounterFlagsEXT surfaceCounters;
- };
- static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
-
- enum class DisplayPowerStateEXT
- {
- eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
- eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
- eOn = VK_DISPLAY_POWER_STATE_ON_EXT
+ RenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const AttachmentDescription* pAttachments;
+ uint32_t subpassCount;
+ const SubpassDescription* pSubpasses;
+ uint32_t dependencyCount;
+ const SubpassDependency* pDependencies;
};
+ static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
- struct DisplayPowerInfoEXT
+ struct SubpassDescription2KHR
{
- DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
- : powerState( powerState_ )
+ SubpassDescription2KHR( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
+ PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+ uint32_t viewMask_ = 0,
+ uint32_t inputAttachmentCount_ = 0,
+ const AttachmentReference2KHR* pInputAttachments_ = nullptr,
+ uint32_t colorAttachmentCount_ = 0,
+ const AttachmentReference2KHR* pColorAttachments_ = nullptr,
+ const AttachmentReference2KHR* pResolveAttachments_ = nullptr,
+ const AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
+ uint32_t preserveAttachmentCount_ = 0,
+ const uint32_t* pPreserveAttachments_ = nullptr )
+ : flags( flags_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , viewMask( viewMask_ )
+ , inputAttachmentCount( inputAttachmentCount_ )
+ , pInputAttachments( pInputAttachments_ )
+ , colorAttachmentCount( colorAttachmentCount_ )
+ , pColorAttachments( pColorAttachments_ )
+ , pResolveAttachments( pResolveAttachments_ )
+ , pDepthStencilAttachment( pDepthStencilAttachment_ )
+ , preserveAttachmentCount( preserveAttachmentCount_ )
+ , pPreserveAttachments( pPreserveAttachments_ )
{
}
- DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
+ SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
+ memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
}
- DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
+ SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
+ memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
return *this;
}
- DisplayPowerInfoEXT& setPNext( const void* pNext_ )
+ SubpassDescription2KHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ )
+ SubpassDescription2KHR& setFlags( SubpassDescriptionFlags flags_ )
{
- powerState = powerState_;
+ flags = flags_;
return *this;
}
- operator const VkDisplayPowerInfoEXT&() const
+ SubpassDescription2KHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
{
- return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
+ pipelineBindPoint = pipelineBindPoint_;
+ return *this;
}
- bool operator==( DisplayPowerInfoEXT const& rhs ) const
+ SubpassDescription2KHR& setViewMask( uint32_t viewMask_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( powerState == rhs.powerState );
+ viewMask = viewMask_;
+ return *this;
}
- bool operator!=( DisplayPowerInfoEXT const& rhs ) const
+ SubpassDescription2KHR& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
{
- return !operator==( rhs );
+ inputAttachmentCount = inputAttachmentCount_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eDisplayPowerInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DisplayPowerStateEXT powerState;
- };
- static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
+ SubpassDescription2KHR& setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ )
+ {
+ pInputAttachments = pInputAttachments_;
+ return *this;
+ }
- enum class DeviceEventTypeEXT
- {
- eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
- };
+ SubpassDescription2KHR& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
+ {
+ colorAttachmentCount = colorAttachmentCount_;
+ return *this;
+ }
- struct DeviceEventInfoEXT
- {
- DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
- : deviceEvent( deviceEvent_ )
+ SubpassDescription2KHR& setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ )
{
+ pColorAttachments = pColorAttachments_;
+ return *this;
}
- DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
+ SubpassDescription2KHR& setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ )
{
- memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
+ pResolveAttachments = pResolveAttachments_;
+ return *this;
}
- DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
+ SubpassDescription2KHR& setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ )
{
- memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
+ pDepthStencilAttachment = pDepthStencilAttachment_;
return *this;
}
- DeviceEventInfoEXT& setPNext( const void* pNext_ )
+
+ SubpassDescription2KHR& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
{
- pNext = pNext_;
+ preserveAttachmentCount = preserveAttachmentCount_;
return *this;
}
- DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
+ SubpassDescription2KHR& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
{
- deviceEvent = deviceEvent_;
+ pPreserveAttachments = pPreserveAttachments_;
return *this;
}
- operator const VkDeviceEventInfoEXT&() const
+ operator VkSubpassDescription2KHR const&() const
{
- return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
+ return *reinterpret_cast<const VkSubpassDescription2KHR*>(this);
}
- bool operator==( DeviceEventInfoEXT const& rhs ) const
+ operator VkSubpassDescription2KHR &()
+ {
+ return *reinterpret_cast<VkSubpassDescription2KHR*>(this);
+ }
+
+ bool operator==( SubpassDescription2KHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( deviceEvent == rhs.deviceEvent );
+ && ( flags == rhs.flags )
+ && ( pipelineBindPoint == rhs.pipelineBindPoint )
+ && ( viewMask == rhs.viewMask )
+ && ( inputAttachmentCount == rhs.inputAttachmentCount )
+ && ( pInputAttachments == rhs.pInputAttachments )
+ && ( colorAttachmentCount == rhs.colorAttachmentCount )
+ && ( pColorAttachments == rhs.pColorAttachments )
+ && ( pResolveAttachments == rhs.pResolveAttachments )
+ && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
+ && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
+ && ( pPreserveAttachments == rhs.pPreserveAttachments );
}
- bool operator!=( DeviceEventInfoEXT const& rhs ) const
+ bool operator!=( SubpassDescription2KHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceEventInfoEXT;
+ StructureType sType = StructureType::eSubpassDescription2KHR;
public:
const void* pNext = nullptr;
- DeviceEventTypeEXT deviceEvent;
- };
- static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
-
- enum class DisplayEventTypeEXT
- {
- eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
+ SubpassDescriptionFlags flags;
+ PipelineBindPoint pipelineBindPoint;
+ uint32_t viewMask;
+ uint32_t inputAttachmentCount;
+ const AttachmentReference2KHR* pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const AttachmentReference2KHR* pColorAttachments;
+ const AttachmentReference2KHR* pResolveAttachments;
+ const AttachmentReference2KHR* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t* pPreserveAttachments;
};
+ static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
- struct DisplayEventInfoEXT
+ struct RenderPassCreateInfo2KHR
{
- DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
- : displayEvent( displayEvent_ )
+ RenderPassCreateInfo2KHR( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
+ uint32_t attachmentCount_ = 0,
+ const AttachmentDescription2KHR* pAttachments_ = nullptr,
+ uint32_t subpassCount_ = 0,
+ const SubpassDescription2KHR* pSubpasses_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const SubpassDependency2KHR* pDependencies_ = nullptr,
+ uint32_t correlatedViewMaskCount_ = 0,
+ const uint32_t* pCorrelatedViewMasks_ = nullptr )
+ : flags( flags_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , subpassCount( subpassCount_ )
+ , pSubpasses( pSubpasses_ )
+ , dependencyCount( dependencyCount_ )
+ , pDependencies( pDependencies_ )
+ , correlatedViewMaskCount( correlatedViewMaskCount_ )
+ , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
{
}
- DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
+ RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
+ memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
}
- DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
+ RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
+ memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
return *this;
}
- DisplayEventInfoEXT& setPNext( const void* pNext_ )
+ RenderPassCreateInfo2KHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
+ RenderPassCreateInfo2KHR& setFlags( RenderPassCreateFlags flags_ )
{
- displayEvent = displayEvent_;
+ flags = flags_;
return *this;
}
- operator const VkDisplayEventInfoEXT&() const
+ RenderPassCreateInfo2KHR& setAttachmentCount( uint32_t attachmentCount_ )
{
- return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
+ attachmentCount = attachmentCount_;
+ return *this;
}
- bool operator==( DisplayEventInfoEXT const& rhs ) const
+ RenderPassCreateInfo2KHR& setPAttachments( const AttachmentDescription2KHR* pAttachments_ )
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( displayEvent == rhs.displayEvent );
+ pAttachments = pAttachments_;
+ return *this;
}
- bool operator!=( DisplayEventInfoEXT const& rhs ) const
+ RenderPassCreateInfo2KHR& setSubpassCount( uint32_t subpassCount_ )
{
- return !operator==( rhs );
+ subpassCount = subpassCount_;
+ return *this;
}
- private:
- StructureType sType = StructureType::eDisplayEventInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DisplayEventTypeEXT displayEvent;
- };
- static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
-
- enum class PeerMemoryFeatureFlagBits
- {
- eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
- eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
- eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
- eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
- eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
- eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
- eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
- eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
- };
-
- using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits, VkPeerMemoryFeatureFlags>;
-
- VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
- {
- return PeerMemoryFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits )
- {
- return ~( PeerMemoryFeatureFlags( bits ) );
- }
-
- template <> struct FlagTraits<PeerMemoryFeatureFlagBits>
- {
- enum
- {
- allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBits::eGenericDst)
- };
- };
-
- using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
-
- enum class MemoryAllocateFlagBits
- {
- eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
- eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
- };
-
- using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits, VkMemoryAllocateFlags>;
-
- VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
- {
- return MemoryAllocateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits )
- {
- return ~( MemoryAllocateFlags( bits ) );
- }
-
- template <> struct FlagTraits<MemoryAllocateFlagBits>
- {
- enum
- {
- allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask)
- };
- };
-
- using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
-
- struct MemoryAllocateFlagsInfo
- {
- MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(),
- uint32_t deviceMask_ = 0 )
- : flags( flags_ )
- , deviceMask( deviceMask_ )
+ RenderPassCreateInfo2KHR& setPSubpasses( const SubpassDescription2KHR* pSubpasses_ )
{
+ pSubpasses = pSubpasses_;
+ return *this;
}
- MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
+ RenderPassCreateInfo2KHR& setDependencyCount( uint32_t dependencyCount_ )
{
- memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
+ dependencyCount = dependencyCount_;
+ return *this;
}
- MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
+ RenderPassCreateInfo2KHR& setPDependencies( const SubpassDependency2KHR* pDependencies_ )
{
- memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
+ pDependencies = pDependencies_;
return *this;
}
- MemoryAllocateFlagsInfo& setPNext( const void* pNext_ )
+
+ RenderPassCreateInfo2KHR& setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ )
{
- pNext = pNext_;
+ correlatedViewMaskCount = correlatedViewMaskCount_;
return *this;
}
- MemoryAllocateFlagsInfo& setFlags( MemoryAllocateFlags flags_ )
+ RenderPassCreateInfo2KHR& setPCorrelatedViewMasks( const uint32_t* pCorrelatedViewMasks_ )
{
- flags = flags_;
+ pCorrelatedViewMasks = pCorrelatedViewMasks_;
return *this;
}
- MemoryAllocateFlagsInfo& setDeviceMask( uint32_t deviceMask_ )
+ operator VkRenderPassCreateInfo2KHR const&() const
{
- deviceMask = deviceMask_;
- return *this;
+ return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>(this);
}
- operator const VkMemoryAllocateFlagsInfo&() const
+ operator VkRenderPassCreateInfo2KHR &()
{
- return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(this);
+ return *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this);
}
- bool operator==( MemoryAllocateFlagsInfo const& rhs ) const
+ bool operator==( RenderPassCreateInfo2KHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( deviceMask == rhs.deviceMask );
+ && ( attachmentCount == rhs.attachmentCount )
+ && ( pAttachments == rhs.pAttachments )
+ && ( subpassCount == rhs.subpassCount )
+ && ( pSubpasses == rhs.pSubpasses )
+ && ( dependencyCount == rhs.dependencyCount )
+ && ( pDependencies == rhs.pDependencies )
+ && ( correlatedViewMaskCount == rhs.correlatedViewMaskCount )
+ && ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks );
}
- bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const
+ bool operator!=( RenderPassCreateInfo2KHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
+ StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
public:
const void* pNext = nullptr;
- MemoryAllocateFlags flags;
- uint32_t deviceMask;
+ RenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const AttachmentDescription2KHR* pAttachments;
+ uint32_t subpassCount;
+ const SubpassDescription2KHR* pSubpasses;
+ uint32_t dependencyCount;
+ const SubpassDependency2KHR* pDependencies;
+ uint32_t correlatedViewMaskCount;
+ const uint32_t* pCorrelatedViewMasks;
};
- static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
-
- using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
+ static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
- enum class DeviceGroupPresentModeFlagBitsKHR
+ enum class PointClippingBehavior
{
- eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR,
- eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR,
- eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR,
- eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
+ eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+ eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+ eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+ eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
};
- using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR, VkDeviceGroupPresentModeFlagsKHR>;
-
- VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
- {
- return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits )
- {
- return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
- }
-
- template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR>
+ struct PhysicalDevicePointClippingProperties
{
- enum
+ operator VkPhysicalDevicePointClippingProperties const&() const
{
- allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
- };
- };
+ return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(this);
+ }
- struct DeviceGroupPresentCapabilitiesKHR
- {
- operator const VkDeviceGroupPresentCapabilitiesKHR&() const
+ operator VkPhysicalDevicePointClippingProperties &()
{
- return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(this);
+ return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this);
}
- bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
+ bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 )
- && ( modes == rhs.modes );
+ && ( pointClippingBehavior == rhs.pointClippingBehavior );
}
- bool operator!=( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
+ bool operator!=( PhysicalDevicePointClippingProperties const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
+ StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
public:
- const void* pNext = nullptr;
- uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
- DeviceGroupPresentModeFlagsKHR modes;
+ void* pNext = nullptr;
+ PointClippingBehavior pointClippingBehavior;
};
- static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
- struct DeviceGroupPresentInfoKHR
+ using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
+
+ enum class SamplerReductionModeEXT
{
- DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
- const uint32_t* pDeviceMasks_ = nullptr,
- DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal )
- : swapchainCount( swapchainCount_ )
- , pDeviceMasks( pDeviceMasks_ )
- , mode( mode_ )
+ eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
+ eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT,
+ eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT
+ };
+
+ struct SamplerReductionModeCreateInfoEXT
+ {
+ SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
+ : reductionMode( reductionMode_ )
{
}
- DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
+ SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
+ memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
}
- DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
+ SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
+ memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
return *this;
}
- DeviceGroupPresentInfoKHR& setPNext( const void* pNext_ )
+ SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DeviceGroupPresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
- {
- swapchainCount = swapchainCount_;
- return *this;
- }
-
- DeviceGroupPresentInfoKHR& setPDeviceMasks( const uint32_t* pDeviceMasks_ )
+ SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ )
{
- pDeviceMasks = pDeviceMasks_;
+ reductionMode = reductionMode_;
return *this;
}
- DeviceGroupPresentInfoKHR& setMode( DeviceGroupPresentModeFlagBitsKHR mode_ )
+ operator VkSamplerReductionModeCreateInfoEXT const&() const
{
- mode = mode_;
- return *this;
+ return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this);
}
- operator const VkDeviceGroupPresentInfoKHR&() const
+ operator VkSamplerReductionModeCreateInfoEXT &()
{
- return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(this);
+ return *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this);
}
- bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const
+ bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( swapchainCount == rhs.swapchainCount )
- && ( pDeviceMasks == rhs.pDeviceMasks )
- && ( mode == rhs.mode );
+ && ( reductionMode == rhs.reductionMode );
}
- bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const
+ bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
+ StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
public:
const void* pNext = nullptr;
- uint32_t swapchainCount;
- const uint32_t* pDeviceMasks;
- DeviceGroupPresentModeFlagBitsKHR mode;
+ SamplerReductionModeEXT reductionMode;
};
- static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
- struct DeviceGroupSwapchainCreateInfoKHR
+ enum class TessellationDomainOrigin
{
- DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() )
- : modes( modes_ )
+ eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+ eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+ eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
+ eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
+ };
+
+ struct PipelineTessellationDomainOriginStateCreateInfo
+ {
+ PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft )
+ : domainOrigin( domainOrigin_ )
{
}
- DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+ PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
}
- DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+ PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
+ memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
return *this;
}
- DeviceGroupSwapchainCreateInfoKHR& setPNext( const void* pNext_ )
+ PipelineTessellationDomainOriginStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DeviceGroupSwapchainCreateInfoKHR& setModes( DeviceGroupPresentModeFlagsKHR modes_ )
+ PipelineTessellationDomainOriginStateCreateInfo& setDomainOrigin( TessellationDomainOrigin domainOrigin_ )
{
- modes = modes_;
+ domainOrigin = domainOrigin_;
return *this;
}
- operator const VkDeviceGroupSwapchainCreateInfoKHR&() const
+ operator VkPipelineTessellationDomainOriginStateCreateInfo const&() const
{
- return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(this);
+ return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
}
- bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
+ operator VkPipelineTessellationDomainOriginStateCreateInfo &()
+ {
+ return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
+ }
+
+ bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( modes == rhs.modes );
+ && ( domainOrigin == rhs.domainOrigin );
}
- bool operator!=( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
+ bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
+ StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
public:
const void* pNext = nullptr;
- DeviceGroupPresentModeFlagsKHR modes;
- };
- static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
-
- enum class SwapchainCreateFlagBitsKHR
- {
- eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR,
- eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR
+ TessellationDomainOrigin domainOrigin;
};
+ static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
- using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
+ using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
- VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ enum class SamplerYcbcrModelConversion
{
- return SwapchainCreateFlagsKHR( bit0 ) | bit1;
- }
+ eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+ eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+ eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+ eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+ eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+ eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+ eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+ eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+ eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
+ eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
+ };
- VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
+ enum class SamplerYcbcrRange
{
- return ~( SwapchainCreateFlagsKHR( bits ) );
- }
+ eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+ eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+ eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+ eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
+ };
- template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
+ enum class ChromaLocation
{
- enum
- {
- allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected)
- };
+ eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
+ eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN,
+ eMidpoint = VK_CHROMA_LOCATION_MIDPOINT,
+ eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT
};
- struct SwapchainCreateInfoKHR
+ struct SamplerYcbcrConversionCreateInfo
{
- SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(),
- SurfaceKHR surface_ = SurfaceKHR(),
- uint32_t minImageCount_ = 0,
- Format imageFormat_ = Format::eUndefined,
- ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear,
- Extent2D imageExtent_ = Extent2D(),
- uint32_t imageArrayLayers_ = 0,
- ImageUsageFlags imageUsage_ = ImageUsageFlags(),
- SharingMode imageSharingMode_ = SharingMode::eExclusive,
- uint32_t queueFamilyIndexCount_ = 0,
- const uint32_t* pQueueFamilyIndices_ = nullptr,
- SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity,
- CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque,
- PresentModeKHR presentMode_ = PresentModeKHR::eImmediate,
- Bool32 clipped_ = 0,
- SwapchainKHR oldSwapchain_ = SwapchainKHR() )
- : flags( flags_ )
- , surface( surface_ )
- , minImageCount( minImageCount_ )
- , imageFormat( imageFormat_ )
- , imageColorSpace( imageColorSpace_ )
- , imageExtent( imageExtent_ )
- , imageArrayLayers( imageArrayLayers_ )
- , imageUsage( imageUsage_ )
- , imageSharingMode( imageSharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
- , preTransform( preTransform_ )
- , compositeAlpha( compositeAlpha_ )
- , presentMode( presentMode_ )
- , clipped( clipped_ )
- , oldSwapchain( oldSwapchain_ )
+ SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined,
+ SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity,
+ SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull,
+ ComponentMapping components_ = ComponentMapping(),
+ ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven,
+ ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven,
+ Filter chromaFilter_ = Filter::eNearest,
+ Bool32 forceExplicitReconstruction_ = 0 )
+ : format( format_ )
+ , ycbcrModel( ycbcrModel_ )
+ , ycbcrRange( ycbcrRange_ )
+ , components( components_ )
+ , xChromaOffset( xChromaOffset_ )
+ , yChromaOffset( yChromaOffset_ )
+ , chromaFilter( chromaFilter_ )
+ , forceExplicitReconstruction( forceExplicitReconstruction_ )
{
}
- SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
+ SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
+ memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
}
- SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
+ SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
+ memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
return *this;
}
- SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
+ SamplerYcbcrConversionCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
+ SamplerYcbcrConversionCreateInfo& setFormat( Format format_ )
{
- flags = flags_;
+ format = format_;
return *this;
}
- SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
+ SamplerYcbcrConversionCreateInfo& setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ )
{
- surface = surface_;
+ ycbcrModel = ycbcrModel_;
return *this;
}
- SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
+ SamplerYcbcrConversionCreateInfo& setYcbcrRange( SamplerYcbcrRange ycbcrRange_ )
{
- minImageCount = minImageCount_;
+ ycbcrRange = ycbcrRange_;
return *this;
}
- SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
+ SamplerYcbcrConversionCreateInfo& setComponents( ComponentMapping components_ )
{
- imageFormat = imageFormat_;
+ components = components_;
return *this;
}
- SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
+ SamplerYcbcrConversionCreateInfo& setXChromaOffset( ChromaLocation xChromaOffset_ )
{
- imageColorSpace = imageColorSpace_;
+ xChromaOffset = xChromaOffset_;
return *this;
}
- SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
+ SamplerYcbcrConversionCreateInfo& setYChromaOffset( ChromaLocation yChromaOffset_ )
{
- imageExtent = imageExtent_;
+ yChromaOffset = yChromaOffset_;
return *this;
}
- SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
+ SamplerYcbcrConversionCreateInfo& setChromaFilter( Filter chromaFilter_ )
{
- imageArrayLayers = imageArrayLayers_;
+ chromaFilter = chromaFilter_;
return *this;
}
- SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
+ SamplerYcbcrConversionCreateInfo& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
{
- imageUsage = imageUsage_;
+ forceExplicitReconstruction = forceExplicitReconstruction_;
return *this;
}
- SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
+ operator VkSamplerYcbcrConversionCreateInfo const&() const
{
- imageSharingMode = imageSharingMode_;
- return *this;
+ return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(this);
}
- SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+ operator VkSamplerYcbcrConversionCreateInfo &()
{
- queueFamilyIndexCount = queueFamilyIndexCount_;
- return *this;
+ return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this);
}
- SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+ bool operator==( SamplerYcbcrConversionCreateInfo const& rhs ) const
{
- pQueueFamilyIndices = pQueueFamilyIndices_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( format == rhs.format )
+ && ( ycbcrModel == rhs.ycbcrModel )
+ && ( ycbcrRange == rhs.ycbcrRange )
+ && ( components == rhs.components )
+ && ( xChromaOffset == rhs.xChromaOffset )
+ && ( yChromaOffset == rhs.yChromaOffset )
+ && ( chromaFilter == rhs.chromaFilter )
+ && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction );
}
- SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
+ bool operator!=( SamplerYcbcrConversionCreateInfo const& rhs ) const
{
- preTransform = preTransform_;
- return *this;
+ return !operator==( rhs );
}
- SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
- {
- compositeAlpha = compositeAlpha_;
- return *this;
- }
+ private:
+ StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
- SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
- {
- presentMode = presentMode_;
- return *this;
- }
+ public:
+ const void* pNext = nullptr;
+ Format format;
+ SamplerYcbcrModelConversion ycbcrModel;
+ SamplerYcbcrRange ycbcrRange;
+ ComponentMapping components;
+ ChromaLocation xChromaOffset;
+ ChromaLocation yChromaOffset;
+ Filter chromaFilter;
+ Bool32 forceExplicitReconstruction;
+ };
+ static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" );
- SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
- {
- clipped = clipped_;
- return *this;
- }
+ using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
- SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
+#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
+ struct AndroidHardwareBufferFormatPropertiesANDROID
+ {
+ operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const
{
- oldSwapchain = oldSwapchain_;
- return *this;
+ return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
}
- operator const VkSwapchainCreateInfoKHR&() const
+ operator VkAndroidHardwareBufferFormatPropertiesANDROID &()
{
- return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
+ return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
}
- bool operator==( SwapchainCreateInfoKHR const& rhs ) const
+ bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( surface == rhs.surface )
- && ( minImageCount == rhs.minImageCount )
- && ( imageFormat == rhs.imageFormat )
- && ( imageColorSpace == rhs.imageColorSpace )
- && ( imageExtent == rhs.imageExtent )
- && ( imageArrayLayers == rhs.imageArrayLayers )
- && ( imageUsage == rhs.imageUsage )
- && ( imageSharingMode == rhs.imageSharingMode )
- && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
- && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
- && ( preTransform == rhs.preTransform )
- && ( compositeAlpha == rhs.compositeAlpha )
- && ( presentMode == rhs.presentMode )
- && ( clipped == rhs.clipped )
- && ( oldSwapchain == rhs.oldSwapchain );
+ && ( format == rhs.format )
+ && ( externalFormat == rhs.externalFormat )
+ && ( formatFeatures == rhs.formatFeatures )
+ && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents )
+ && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel )
+ && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange )
+ && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset )
+ && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
}
- bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
+ bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSwapchainCreateInfoKHR;
+ StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
public:
- const void* pNext = nullptr;
- SwapchainCreateFlagsKHR flags;
- SurfaceKHR surface;
- uint32_t minImageCount;
- Format imageFormat;
- ColorSpaceKHR imageColorSpace;
- Extent2D imageExtent;
- uint32_t imageArrayLayers;
- ImageUsageFlags imageUsage;
- SharingMode imageSharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- SurfaceTransformFlagBitsKHR preTransform;
- CompositeAlphaFlagBitsKHR compositeAlpha;
- PresentModeKHR presentMode;
- Bool32 clipped;
- SwapchainKHR oldSwapchain;
+ void* pNext = nullptr;
+ Format format;
+ uint64_t externalFormat;
+ FormatFeatureFlags formatFeatures;
+ ComponentMapping samplerYcbcrConversionComponents;
+ SamplerYcbcrModelConversion suggestedYcbcrModel;
+ SamplerYcbcrRange suggestedYcbcrRange;
+ ChromaLocation suggestedXChromaOffset;
+ ChromaLocation suggestedYChromaOffset;
};
- static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
- enum class ViewportCoordinateSwizzleNV
+ enum class BlendOverlapEXT
{
- ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
- eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
- ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
- eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
- ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
- eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
- ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
- eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+ eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
+ eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
+ eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
};
- struct ViewportSwizzleNV
+ struct PipelineColorBlendAdvancedStateCreateInfoEXT
{
- ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX,
- ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX,
- ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX,
- ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX )
- : x( x_ )
- , y( y_ )
- , z( z_ )
- , w( w_ )
- {
- }
-
- ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
- }
-
- ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
- return *this;
- }
- ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0,
+ Bool32 dstPremultiplied_ = 0,
+ BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
+ : srcPremultiplied( srcPremultiplied_ )
+ , dstPremultiplied( dstPremultiplied_ )
+ , blendOverlap( blendOverlap_ )
{
- x = x_;
- return *this;
}
- ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
{
- y = y_;
- return *this;
+ memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
}
- ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
{
- z = z_;
+ memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
return *this;
}
-
- ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ )
{
- w = w_;
+ pNext = pNext_;
return *this;
}
- operator const VkViewportSwizzleNV&() const
- {
- return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
- }
-
- bool operator==( ViewportSwizzleNV const& rhs ) const
- {
- return ( x == rhs.x )
- && ( y == rhs.y )
- && ( z == rhs.z )
- && ( w == rhs.w );
- }
-
- bool operator!=( ViewportSwizzleNV const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- ViewportCoordinateSwizzleNV x;
- ViewportCoordinateSwizzleNV y;
- ViewportCoordinateSwizzleNV z;
- ViewportCoordinateSwizzleNV w;
- };
- static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
-
- struct PipelineViewportSwizzleStateCreateInfoNV
- {
- PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(),
- uint32_t viewportCount_ = 0,
- const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
- : flags( flags_ )
- , viewportCount( viewportCount_ )
- , pViewportSwizzles( pViewportSwizzles_ )
- {
- }
-
- PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
- }
-
- PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
- return *this;
- }
- PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ )
{
- pNext = pNext_;
+ srcPremultiplied = srcPremultiplied_;
return *this;
}
- PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ )
{
- flags = flags_;
+ dstPremultiplied = dstPremultiplied_;
return *this;
}
- PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ )
{
- viewportCount = viewportCount_;
+ blendOverlap = blendOverlap_;
return *this;
}
- PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
+ operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const
{
- pViewportSwizzles = pViewportSwizzles_;
- return *this;
+ return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
}
- operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const
+ operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &()
{
- return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+ return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
}
- bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
+ bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( viewportCount == rhs.viewportCount )
- && ( pViewportSwizzles == rhs.pViewportSwizzles );
+ && ( srcPremultiplied == rhs.srcPremultiplied )
+ && ( dstPremultiplied == rhs.dstPremultiplied )
+ && ( blendOverlap == rhs.blendOverlap );
}
- bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
+ bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
+ StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
public:
const void* pNext = nullptr;
- PipelineViewportSwizzleStateCreateFlagsNV flags;
- uint32_t viewportCount;
- const ViewportSwizzleNV* pViewportSwizzles;
+ Bool32 srcPremultiplied;
+ Bool32 dstPremultiplied;
+ BlendOverlapEXT blendOverlap;
};
- static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
- enum class DiscardRectangleModeEXT
+ enum class CoverageModulationModeNV
{
- eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
- eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
+ eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
+ eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
+ eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
+ eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
};
- struct PipelineDiscardRectangleStateCreateInfoEXT
+ struct PipelineCoverageModulationStateCreateInfoNV
{
- PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(),
- DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive,
- uint32_t discardRectangleCount_ = 0,
- const Rect2D* pDiscardRectangles_ = nullptr )
+ PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(),
+ CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone,
+ Bool32 coverageModulationTableEnable_ = 0,
+ uint32_t coverageModulationTableCount_ = 0,
+ const float* pCoverageModulationTable_ = nullptr )
: flags( flags_ )
- , discardRectangleMode( discardRectangleMode_ )
- , discardRectangleCount( discardRectangleCount_ )
- , pDiscardRectangles( pDiscardRectangles_ )
+ , coverageModulationMode( coverageModulationMode_ )
+ , coverageModulationTableEnable( coverageModulationTableEnable_ )
+ , coverageModulationTableCount( coverageModulationTableCount_ )
+ , pCoverageModulationTable( pCoverageModulationTable_ )
{
}
- PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+ PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
}
- PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+ PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ )
+ PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
+ PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
+ {
+ coverageModulationMode = coverageModulationMode_;
+ return *this;
+ }
+
+ PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
{
- flags = flags_;
+ coverageModulationTableEnable = coverageModulationTableEnable_;
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
+ PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ )
{
- discardRectangleMode = discardRectangleMode_;
+ coverageModulationTableCount = coverageModulationTableCount_;
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ )
+ PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ )
{
- discardRectangleCount = discardRectangleCount_;
+ pCoverageModulationTable = pCoverageModulationTable_;
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
+ operator VkPipelineCoverageModulationStateCreateInfoNV const&() const
{
- pDiscardRectangles = pDiscardRectangles_;
- return *this;
+ return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this);
}
- operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const
+ operator VkPipelineCoverageModulationStateCreateInfoNV &()
{
- return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
+ return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this);
}
- bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
+ bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( discardRectangleMode == rhs.discardRectangleMode )
- && ( discardRectangleCount == rhs.discardRectangleCount )
- && ( pDiscardRectangles == rhs.pDiscardRectangles );
+ && ( coverageModulationMode == rhs.coverageModulationMode )
+ && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable )
+ && ( coverageModulationTableCount == rhs.coverageModulationTableCount )
+ && ( pCoverageModulationTable == rhs.pCoverageModulationTable );
}
- bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
+ bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
+ StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
public:
const void* pNext = nullptr;
- PipelineDiscardRectangleStateCreateFlagsEXT flags;
- DiscardRectangleModeEXT discardRectangleMode;
- uint32_t discardRectangleCount;
- const Rect2D* pDiscardRectangles;
+ PipelineCoverageModulationStateCreateFlagsNV flags;
+ CoverageModulationModeNV coverageModulationMode;
+ Bool32 coverageModulationTableEnable;
+ uint32_t coverageModulationTableCount;
+ const float* pCoverageModulationTable;
};
- static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
- enum class SubpassDescriptionFlagBits
+ enum class ValidationCacheHeaderVersionEXT
{
- ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
- ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
+ eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
};
- using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
-
- VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
- {
- return SubpassDescriptionFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
+ enum class ShaderInfoTypeAMD
{
- return ~( SubpassDescriptionFlags( bits ) );
- }
+ eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
+ eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
+ eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
+ };
- template <> struct FlagTraits<SubpassDescriptionFlagBits>
+ enum class QueueGlobalPriorityEXT
{
- enum
- {
- allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
- };
+ eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
+ eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
+ eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
+ eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
};
- struct SubpassDescription
+ struct DeviceQueueGlobalPriorityCreateInfoEXT
{
- SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
- PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- uint32_t inputAttachmentCount_ = 0,
- const AttachmentReference* pInputAttachments_ = nullptr,
- uint32_t colorAttachmentCount_ = 0,
- const AttachmentReference* pColorAttachments_ = nullptr,
- const AttachmentReference* pResolveAttachments_ = nullptr,
- const AttachmentReference* pDepthStencilAttachment_ = nullptr,
- uint32_t preserveAttachmentCount_ = 0,
- const uint32_t* pPreserveAttachments_ = nullptr )
- : flags( flags_ )
- , pipelineBindPoint( pipelineBindPoint_ )
- , inputAttachmentCount( inputAttachmentCount_ )
- , pInputAttachments( pInputAttachments_ )
- , colorAttachmentCount( colorAttachmentCount_ )
- , pColorAttachments( pColorAttachments_ )
- , pResolveAttachments( pResolveAttachments_ )
- , pDepthStencilAttachment( pDepthStencilAttachment_ )
- , preserveAttachmentCount( preserveAttachmentCount_ )
- , pPreserveAttachments( pPreserveAttachments_ )
+ DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
+ : globalPriority( globalPriority_ )
{
}
- SubpassDescription( VkSubpassDescription const & rhs )
+ DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription ) );
+ memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
}
- SubpassDescription& operator=( VkSubpassDescription const & rhs )
+ DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription ) );
+ memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
return *this;
}
- SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
+ DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ )
{
- flags = flags_;
+ pNext = pNext_;
return *this;
}
- SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
{
- pipelineBindPoint = pipelineBindPoint_;
+ globalPriority = globalPriority_;
return *this;
}
- SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
+ operator VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const
{
- inputAttachmentCount = inputAttachmentCount_;
- return *this;
+ return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
}
- SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
+ operator VkDeviceQueueGlobalPriorityCreateInfoEXT &()
{
- pInputAttachments = pInputAttachments_;
- return *this;
+ return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
}
- SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
+ bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
{
- colorAttachmentCount = colorAttachmentCount_;
- return *this;
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( globalPriority == rhs.globalPriority );
}
- SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
+ bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
{
- pColorAttachments = pColorAttachments_;
- return *this;
+ return !operator==( rhs );
}
- SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
- {
- pResolveAttachments = pResolveAttachments_;
- return *this;
- }
+ private:
+ StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
- SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
- {
- pDepthStencilAttachment = pDepthStencilAttachment_;
- return *this;
- }
+ public:
+ const void* pNext = nullptr;
+ QueueGlobalPriorityEXT globalPriority;
+ };
+ static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
- SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
- {
- preserveAttachmentCount = preserveAttachmentCount_;
- return *this;
- }
+ enum class DebugUtilsMessageSeverityFlagBitsEXT
+ {
+ eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
+ eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
+ eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
+ eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
+ };
- SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
- {
- pPreserveAttachments = pPreserveAttachments_;
- return *this;
- }
+ using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageSeverityFlagsEXT>;
- operator const VkSubpassDescription&() const
- {
- return *reinterpret_cast<const VkSubpassDescription*>(this);
- }
+ VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
+ }
- bool operator==( SubpassDescription const& rhs ) const
- {
- return ( flags == rhs.flags )
- && ( pipelineBindPoint == rhs.pipelineBindPoint )
- && ( inputAttachmentCount == rhs.inputAttachmentCount )
- && ( pInputAttachments == rhs.pInputAttachments )
- && ( colorAttachmentCount == rhs.colorAttachmentCount )
- && ( pColorAttachments == rhs.pColorAttachments )
- && ( pResolveAttachments == rhs.pResolveAttachments )
- && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
- && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
- && ( pPreserveAttachments == rhs.pPreserveAttachments );
- }
+ VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits )
+ {
+ return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) );
+ }
- bool operator!=( SubpassDescription const& rhs ) const
+ template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT>
+ {
+ enum
{
- return !operator==( rhs );
- }
+ allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError)
+ };
+ };
- SubpassDescriptionFlags flags;
- PipelineBindPoint pipelineBindPoint;
- uint32_t inputAttachmentCount;
- const AttachmentReference* pInputAttachments;
- uint32_t colorAttachmentCount;
- const AttachmentReference* pColorAttachments;
- const AttachmentReference* pResolveAttachments;
- const AttachmentReference* pDepthStencilAttachment;
- uint32_t preserveAttachmentCount;
- const uint32_t* pPreserveAttachments;
+ enum class DebugUtilsMessageTypeFlagBitsEXT
+ {
+ eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
+ eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
+ ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
};
- static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
- struct RenderPassCreateInfo
+ using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT>;
+
+ VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
{
- RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
- uint32_t attachmentCount_ = 0,
- const AttachmentDescription* pAttachments_ = nullptr,
- uint32_t subpassCount_ = 0,
- const SubpassDescription* pSubpasses_ = nullptr,
- uint32_t dependencyCount_ = 0,
- const SubpassDependency* pDependencies_ = nullptr )
+ return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits )
+ {
+ return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
+ }
+
+ template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT>
+ {
+ enum
+ {
+ allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
+ };
+ };
+
+ struct DebugUtilsMessengerCreateInfoEXT
+ {
+ DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(),
+ DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(),
+ DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(),
+ PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
+ void* pUserData_ = nullptr )
: flags( flags_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , subpassCount( subpassCount_ )
- , pSubpasses( pSubpasses_ )
- , dependencyCount( dependencyCount_ )
- , pDependencies( pDependencies_ )
+ , messageSeverity( messageSeverity_ )
+ , messageType( messageType_ )
+ , pfnUserCallback( pfnUserCallback_ )
+ , pUserData( pUserData_ )
{
}
- RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
+ DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
}
- RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
+ DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
+ memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
return *this;
}
- RenderPassCreateInfo& setPNext( const void* pNext_ )
+ DebugUtilsMessengerCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
+ DebugUtilsMessengerCreateInfoEXT& setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
- {
- attachmentCount = attachmentCount_;
- return *this;
- }
-
- RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
+ DebugUtilsMessengerCreateInfoEXT& setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
{
- pAttachments = pAttachments_;
+ messageSeverity = messageSeverity_;
return *this;
}
- RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
+ DebugUtilsMessengerCreateInfoEXT& setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ )
{
- subpassCount = subpassCount_;
+ messageType = messageType_;
return *this;
}
- RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
+ DebugUtilsMessengerCreateInfoEXT& setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ )
{
- pSubpasses = pSubpasses_;
+ pfnUserCallback = pfnUserCallback_;
return *this;
}
- RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
+ DebugUtilsMessengerCreateInfoEXT& setPUserData( void* pUserData_ )
{
- dependencyCount = dependencyCount_;
+ pUserData = pUserData_;
return *this;
}
- RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
+ operator VkDebugUtilsMessengerCreateInfoEXT const&() const
{
- pDependencies = pDependencies_;
- return *this;
+ return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(this);
}
- operator const VkRenderPassCreateInfo&() const
+ operator VkDebugUtilsMessengerCreateInfoEXT &()
{
- return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
+ return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this);
}
- bool operator==( RenderPassCreateInfo const& rhs ) const
+ bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( attachmentCount == rhs.attachmentCount )
- && ( pAttachments == rhs.pAttachments )
- && ( subpassCount == rhs.subpassCount )
- && ( pSubpasses == rhs.pSubpasses )
- && ( dependencyCount == rhs.dependencyCount )
- && ( pDependencies == rhs.pDependencies );
+ && ( messageSeverity == rhs.messageSeverity )
+ && ( messageType == rhs.messageType )
+ && ( pfnUserCallback == rhs.pfnUserCallback )
+ && ( pUserData == rhs.pUserData );
}
- bool operator!=( RenderPassCreateInfo const& rhs ) const
+ bool operator!=( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eRenderPassCreateInfo;
+ StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
public:
const void* pNext = nullptr;
- RenderPassCreateFlags flags;
- uint32_t attachmentCount;
- const AttachmentDescription* pAttachments;
- uint32_t subpassCount;
- const SubpassDescription* pSubpasses;
- uint32_t dependencyCount;
- const SubpassDependency* pDependencies;
+ DebugUtilsMessengerCreateFlagsEXT flags;
+ DebugUtilsMessageSeverityFlagsEXT messageSeverity;
+ DebugUtilsMessageTypeFlagsEXT messageType;
+ PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
+ void* pUserData;
};
- static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
- struct SubpassDescription2KHR
+ enum class ConservativeRasterizationModeEXT
{
- SubpassDescription2KHR( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
- PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- uint32_t viewMask_ = 0,
- uint32_t inputAttachmentCount_ = 0,
- const AttachmentReference2KHR* pInputAttachments_ = nullptr,
- uint32_t colorAttachmentCount_ = 0,
- const AttachmentReference2KHR* pColorAttachments_ = nullptr,
- const AttachmentReference2KHR* pResolveAttachments_ = nullptr,
- const AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
- uint32_t preserveAttachmentCount_ = 0,
- const uint32_t* pPreserveAttachments_ = nullptr )
+ eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
+ eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
+ eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
+ };
+
+ struct PipelineRasterizationConservativeStateCreateInfoEXT
+ {
+ PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(),
+ ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled,
+ float extraPrimitiveOverestimationSize_ = 0 )
: flags( flags_ )
- , pipelineBindPoint( pipelineBindPoint_ )
- , viewMask( viewMask_ )
- , inputAttachmentCount( inputAttachmentCount_ )
- , pInputAttachments( pInputAttachments_ )
- , colorAttachmentCount( colorAttachmentCount_ )
- , pColorAttachments( pColorAttachments_ )
- , pResolveAttachments( pResolveAttachments_ )
- , pDepthStencilAttachment( pDepthStencilAttachment_ )
- , preserveAttachmentCount( preserveAttachmentCount_ )
- , pPreserveAttachments( pPreserveAttachments_ )
+ , conservativeRasterizationMode( conservativeRasterizationMode_ )
+ , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
{
}
- SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
+ PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
}
- SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs )
+ PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
return *this;
}
- SubpassDescription2KHR& setPNext( const void* pNext_ )
+ PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SubpassDescription2KHR& setFlags( SubpassDescriptionFlags flags_ )
+ PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- SubpassDescription2KHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
- {
- pipelineBindPoint = pipelineBindPoint_;
- return *this;
- }
-
- SubpassDescription2KHR& setViewMask( uint32_t viewMask_ )
- {
- viewMask = viewMask_;
- return *this;
- }
-
- SubpassDescription2KHR& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
- {
- inputAttachmentCount = inputAttachmentCount_;
- return *this;
- }
-
- SubpassDescription2KHR& setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ )
- {
- pInputAttachments = pInputAttachments_;
- return *this;
- }
-
- SubpassDescription2KHR& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
- {
- colorAttachmentCount = colorAttachmentCount_;
- return *this;
- }
-
- SubpassDescription2KHR& setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ )
- {
- pColorAttachments = pColorAttachments_;
- return *this;
- }
-
- SubpassDescription2KHR& setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ )
- {
- pResolveAttachments = pResolveAttachments_;
- return *this;
- }
-
- SubpassDescription2KHR& setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ )
+ PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
{
- pDepthStencilAttachment = pDepthStencilAttachment_;
+ conservativeRasterizationMode = conservativeRasterizationMode_;
return *this;
}
- SubpassDescription2KHR& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
+ PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ )
{
- preserveAttachmentCount = preserveAttachmentCount_;
+ extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
return *this;
}
- SubpassDescription2KHR& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
+ operator VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const
{
- pPreserveAttachments = pPreserveAttachments_;
- return *this;
+ return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
}
- operator const VkSubpassDescription2KHR&() const
+ operator VkPipelineRasterizationConservativeStateCreateInfoEXT &()
{
- return *reinterpret_cast<const VkSubpassDescription2KHR*>(this);
+ return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
}
- bool operator==( SubpassDescription2KHR const& rhs ) const
+ bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( flags == rhs.flags )
- && ( pipelineBindPoint == rhs.pipelineBindPoint )
- && ( viewMask == rhs.viewMask )
- && ( inputAttachmentCount == rhs.inputAttachmentCount )
- && ( pInputAttachments == rhs.pInputAttachments )
- && ( colorAttachmentCount == rhs.colorAttachmentCount )
- && ( pColorAttachments == rhs.pColorAttachments )
- && ( pResolveAttachments == rhs.pResolveAttachments )
- && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
- && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
- && ( pPreserveAttachments == rhs.pPreserveAttachments );
+ && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode )
+ && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
}
- bool operator!=( SubpassDescription2KHR const& rhs ) const
+ bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSubpassDescription2KHR;
+ StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
public:
const void* pNext = nullptr;
- SubpassDescriptionFlags flags;
- PipelineBindPoint pipelineBindPoint;
- uint32_t viewMask;
- uint32_t inputAttachmentCount;
- const AttachmentReference2KHR* pInputAttachments;
- uint32_t colorAttachmentCount;
- const AttachmentReference2KHR* pColorAttachments;
- const AttachmentReference2KHR* pResolveAttachments;
- const AttachmentReference2KHR* pDepthStencilAttachment;
- uint32_t preserveAttachmentCount;
- const uint32_t* pPreserveAttachments;
+ PipelineRasterizationConservativeStateCreateFlagsEXT flags;
+ ConservativeRasterizationModeEXT conservativeRasterizationMode;
+ float extraPrimitiveOverestimationSize;
};
- static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
- struct RenderPassCreateInfo2KHR
+ enum class DescriptorBindingFlagBitsEXT
{
- RenderPassCreateInfo2KHR( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
- uint32_t attachmentCount_ = 0,
- const AttachmentDescription2KHR* pAttachments_ = nullptr,
- uint32_t subpassCount_ = 0,
- const SubpassDescription2KHR* pSubpasses_ = nullptr,
- uint32_t dependencyCount_ = 0,
- const SubpassDependency2KHR* pDependencies_ = nullptr,
- uint32_t correlatedViewMaskCount_ = 0,
- const uint32_t* pCorrelatedViewMasks_ = nullptr )
- : flags( flags_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , subpassCount( subpassCount_ )
- , pSubpasses( pSubpasses_ )
- , dependencyCount( dependencyCount_ )
- , pDependencies( pDependencies_ )
- , correlatedViewMaskCount( correlatedViewMaskCount_ )
- , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
- {
- }
-
- RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
- }
+ eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
+ eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT,
+ ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT,
+ eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT
+ };
- RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
- return *this;
- }
- RenderPassCreateInfo2KHR& setPNext( const void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
+ using DescriptorBindingFlagsEXT = Flags<DescriptorBindingFlagBitsEXT, VkDescriptorBindingFlagsEXT>;
- RenderPassCreateInfo2KHR& setFlags( RenderPassCreateFlags flags_ )
- {
- flags = flags_;
- return *this;
- }
+ VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+ {
+ return DescriptorBindingFlagsEXT( bit0 ) | bit1;
+ }
- RenderPassCreateInfo2KHR& setAttachmentCount( uint32_t attachmentCount_ )
+ VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits )
+ {
+ return ~( DescriptorBindingFlagsEXT( bits ) );
+ }
+
+ template <> struct FlagTraits<DescriptorBindingFlagBitsEXT>
+ {
+ enum
{
- attachmentCount = attachmentCount_;
- return *this;
- }
+ allFlags = VkFlags(DescriptorBindingFlagBitsEXT::eUpdateAfterBind) | VkFlags(DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) | VkFlags(DescriptorBindingFlagBitsEXT::ePartiallyBound) | VkFlags(DescriptorBindingFlagBitsEXT::eVariableDescriptorCount)
+ };
+ };
- RenderPassCreateInfo2KHR& setPAttachments( const AttachmentDescription2KHR* pAttachments_ )
+ struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
+ {
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
+ const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
+ : bindingCount( bindingCount_ )
+ , pBindingFlags( pBindingFlags_ )
{
- pAttachments = pAttachments_;
- return *this;
}
- RenderPassCreateInfo2KHR& setSubpassCount( uint32_t subpassCount_ )
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
{
- subpassCount = subpassCount_;
- return *this;
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
}
- RenderPassCreateInfo2KHR& setPSubpasses( const SubpassDescription2KHR* pSubpasses_ )
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
{
- pSubpasses = pSubpasses_;
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
return *this;
}
-
- RenderPassCreateInfo2KHR& setDependencyCount( uint32_t dependencyCount_ )
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPNext( const void* pNext_ )
{
- dependencyCount = dependencyCount_;
+ pNext = pNext_;
return *this;
}
- RenderPassCreateInfo2KHR& setPDependencies( const SubpassDependency2KHR* pDependencies_ )
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT& setBindingCount( uint32_t bindingCount_ )
{
- pDependencies = pDependencies_;
+ bindingCount = bindingCount_;
return *this;
}
- RenderPassCreateInfo2KHR& setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ )
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ )
{
- correlatedViewMaskCount = correlatedViewMaskCount_;
+ pBindingFlags = pBindingFlags_;
return *this;
}
- RenderPassCreateInfo2KHR& setPCorrelatedViewMasks( const uint32_t* pCorrelatedViewMasks_ )
+ operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const&() const
{
- pCorrelatedViewMasks = pCorrelatedViewMasks_;
- return *this;
+ return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
}
- operator const VkRenderPassCreateInfo2KHR&() const
+ operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT &()
{
- return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>(this);
+ return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
}
- bool operator==( RenderPassCreateInfo2KHR const& rhs ) const
+ bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( attachmentCount == rhs.attachmentCount )
- && ( pAttachments == rhs.pAttachments )
- && ( subpassCount == rhs.subpassCount )
- && ( pSubpasses == rhs.pSubpasses )
- && ( dependencyCount == rhs.dependencyCount )
- && ( pDependencies == rhs.pDependencies )
- && ( correlatedViewMaskCount == rhs.correlatedViewMaskCount )
- && ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks );
+ && ( bindingCount == rhs.bindingCount )
+ && ( pBindingFlags == rhs.pBindingFlags );
}
- bool operator!=( RenderPassCreateInfo2KHR const& rhs ) const
+ bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
+ StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
public:
const void* pNext = nullptr;
- RenderPassCreateFlags flags;
- uint32_t attachmentCount;
- const AttachmentDescription2KHR* pAttachments;
- uint32_t subpassCount;
- const SubpassDescription2KHR* pSubpasses;
- uint32_t dependencyCount;
- const SubpassDependency2KHR* pDependencies;
- uint32_t correlatedViewMaskCount;
- const uint32_t* pCorrelatedViewMasks;
+ uint32_t bindingCount;
+ const DescriptorBindingFlagsEXT* pBindingFlags;
};
- static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
- enum class PointClippingBehavior
+ enum class VendorId
{
- eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
- eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
- eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
- eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
+ eViv = VK_VENDOR_ID_VIV,
+ eVsi = VK_VENDOR_ID_VSI,
+ eKazan = VK_VENDOR_ID_KAZAN
};
- struct PhysicalDevicePointClippingProperties
+ enum class DriverIdKHR
+ {
+ eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
+ eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR,
+ eMesaRadv = VK_DRIVER_ID_MESA_RADV_KHR,
+ eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR,
+ eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR,
+ eIntelOpenSourceMesa = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR,
+ eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR,
+ eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR,
+ eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR
+ };
+
+ struct PhysicalDeviceDriverPropertiesKHR
{
- operator const VkPhysicalDevicePointClippingProperties&() const
+ operator VkPhysicalDeviceDriverPropertiesKHR const&() const
{
- return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(this);
+ return *reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR*>(this);
}
- bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const
+ operator VkPhysicalDeviceDriverPropertiesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this);
+ }
+
+ bool operator==( PhysicalDeviceDriverPropertiesKHR const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( pointClippingBehavior == rhs.pointClippingBehavior );
+ && ( driverID == rhs.driverID )
+ && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE_KHR * sizeof( char ) ) == 0 )
+ && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE_KHR * sizeof( char ) ) == 0 )
+ && ( conformanceVersion == rhs.conformanceVersion );
}
- bool operator!=( PhysicalDevicePointClippingProperties const& rhs ) const
+ bool operator!=( PhysicalDeviceDriverPropertiesKHR const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
+ StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
public:
void* pNext = nullptr;
- PointClippingBehavior pointClippingBehavior;
+ DriverIdKHR driverID;
+ char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
+ char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
+ ConformanceVersionKHR conformanceVersion;
};
- static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" );
- using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
+ enum class ConditionalRenderingFlagBitsEXT
+ {
+ eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
+ };
- enum class SamplerReductionModeEXT
+ using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT, VkConditionalRenderingFlagsEXT>;
+
+ VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
{
- eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
- eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT,
- eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT
+ return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits )
+ {
+ return ~( ConditionalRenderingFlagsEXT( bits ) );
+ }
+
+ template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT>
+ {
+ enum
+ {
+ allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted)
+ };
};
- struct SamplerReductionModeCreateInfoEXT
+ struct ConditionalRenderingBeginInfoEXT
{
- SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
- : reductionMode( reductionMode_ )
+ ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(),
+ DeviceSize offset_ = 0,
+ ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() )
+ : buffer( buffer_ )
+ , offset( offset_ )
+ , flags( flags_ )
{
}
- SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
+ ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
}
- SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
+ ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
return *this;
}
- SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ )
+ ConditionalRenderingBeginInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ )
+ ConditionalRenderingBeginInfoEXT& setBuffer( Buffer buffer_ )
{
- reductionMode = reductionMode_;
+ buffer = buffer_;
return *this;
}
- operator const VkSamplerReductionModeCreateInfoEXT&() const
+ ConditionalRenderingBeginInfoEXT& setOffset( DeviceSize offset_ )
{
- return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this);
+ offset = offset_;
+ return *this;
}
- bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const
+ ConditionalRenderingBeginInfoEXT& setFlags( ConditionalRenderingFlagsEXT flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ operator VkConditionalRenderingBeginInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(this);
+ }
+
+ operator VkConditionalRenderingBeginInfoEXT &()
+ {
+ return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this);
+ }
+
+ bool operator==( ConditionalRenderingBeginInfoEXT const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( reductionMode == rhs.reductionMode );
+ && ( buffer == rhs.buffer )
+ && ( offset == rhs.offset )
+ && ( flags == rhs.flags );
}
- bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const
+ bool operator!=( ConditionalRenderingBeginInfoEXT const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
+ StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
public:
const void* pNext = nullptr;
- SamplerReductionModeEXT reductionMode;
+ Buffer buffer;
+ DeviceSize offset;
+ ConditionalRenderingFlagsEXT flags;
};
- static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
- enum class TessellationDomainOrigin
+ enum class ShadingRatePaletteEntryNV
{
- eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
- eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
- eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
- eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
+ eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
+ e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
+ e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
+ e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
+ e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
+ e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
+ e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
+ e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
+ e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
+ e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
+ e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
+ e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
};
- struct PipelineTessellationDomainOriginStateCreateInfo
+ struct ShadingRatePaletteNV
{
- PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft )
- : domainOrigin( domainOrigin_ )
+ ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
+ const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
+ : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
+ , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
{
}
- PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+ ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
}
- PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+ ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
+ memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
return *this;
}
- PipelineTessellationDomainOriginStateCreateInfo& setPNext( const void* pNext_ )
+ ShadingRatePaletteNV& setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ )
+ {
+ shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
+ return *this;
+ }
+
+ ShadingRatePaletteNV& setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
+ {
+ pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
+ return *this;
+ }
+
+ operator VkShadingRatePaletteNV const&() const
+ {
+ return *reinterpret_cast<const VkShadingRatePaletteNV*>(this);
+ }
+
+ operator VkShadingRatePaletteNV &()
+ {
+ return *reinterpret_cast<VkShadingRatePaletteNV*>(this);
+ }
+
+ bool operator==( ShadingRatePaletteNV const& rhs ) const
+ {
+ return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount )
+ && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
+ }
+
+ bool operator!=( ShadingRatePaletteNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ uint32_t shadingRatePaletteEntryCount;
+ const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
+ };
+ static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
+
+ struct PipelineViewportShadingRateImageStateCreateInfoNV
+ {
+ PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0,
+ uint32_t viewportCount_ = 0,
+ const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+ : shadingRateImageEnable( shadingRateImageEnable_ )
+ , viewportCount( viewportCount_ )
+ , pShadingRatePalettes( pShadingRatePalettes_ )
+ {
+ }
+
+ PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+ }
+
+ PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+ return *this;
+ }
+ PipelineViewportShadingRateImageStateCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineTessellationDomainOriginStateCreateInfo& setDomainOrigin( TessellationDomainOrigin domainOrigin_ )
+ PipelineViewportShadingRateImageStateCreateInfoNV& setShadingRateImageEnable( Bool32 shadingRateImageEnable_ )
{
- domainOrigin = domainOrigin_;
+ shadingRateImageEnable = shadingRateImageEnable_;
return *this;
}
- operator const VkPipelineTessellationDomainOriginStateCreateInfo&() const
+ PipelineViewportShadingRateImageStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
{
- return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
+ viewportCount = viewportCount_;
+ return *this;
}
- bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
+ PipelineViewportShadingRateImageStateCreateInfoNV& setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ )
+ {
+ pShadingRatePalettes = pShadingRatePalettes_;
+ return *this;
+ }
+
+ operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const
+ {
+ return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
+ }
+
+ operator VkPipelineViewportShadingRateImageStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
+ }
+
+ bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( domainOrigin == rhs.domainOrigin );
+ && ( shadingRateImageEnable == rhs.shadingRateImageEnable )
+ && ( viewportCount == rhs.viewportCount )
+ && ( pShadingRatePalettes == rhs.pShadingRatePalettes );
}
- bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
+ bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
+ StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
public:
const void* pNext = nullptr;
- TessellationDomainOrigin domainOrigin;
- };
- static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
-
- using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
-
- enum class SamplerYcbcrModelConversion
- {
- eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
- eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
- eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
- eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
- eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
- eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
- eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
- eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
- eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
- eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
- };
-
- enum class SamplerYcbcrRange
- {
- eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
- eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
- eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
- eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
- };
-
- enum class ChromaLocation
- {
- eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
- eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN,
- eMidpoint = VK_CHROMA_LOCATION_MIDPOINT,
- eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT
+ Bool32 shadingRateImageEnable;
+ uint32_t viewportCount;
+ const ShadingRatePaletteNV* pShadingRatePalettes;
};
+ static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
- struct SamplerYcbcrConversionCreateInfo
+ struct CoarseSampleOrderCustomNV
{
- SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined,
- SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity,
- SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull,
- ComponentMapping components_ = ComponentMapping(),
- ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven,
- ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven,
- Filter chromaFilter_ = Filter::eNearest,
- Bool32 forceExplicitReconstruction_ = 0 )
- : format( format_ )
- , ycbcrModel( ycbcrModel_ )
- , ycbcrRange( ycbcrRange_ )
- , components( components_ )
- , xChromaOffset( xChromaOffset_ )
- , yChromaOffset( yChromaOffset_ )
- , chromaFilter( chromaFilter_ )
- , forceExplicitReconstruction( forceExplicitReconstruction_ )
+ CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations,
+ uint32_t sampleCount_ = 0,
+ uint32_t sampleLocationCount_ = 0,
+ const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
+ : shadingRate( shadingRate_ )
+ , sampleCount( sampleCount_ )
+ , sampleLocationCount( sampleLocationCount_ )
+ , pSampleLocations( pSampleLocations_ )
{
}
- SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
+ CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
+ memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
}
- SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs )
+ CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
+ memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
return *this;
}
- SamplerYcbcrConversionCreateInfo& setPNext( const void* pNext_ )
+ CoarseSampleOrderCustomNV& setShadingRate( ShadingRatePaletteEntryNV shadingRate_ )
{
- pNext = pNext_;
+ shadingRate = shadingRate_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setFormat( Format format_ )
+ CoarseSampleOrderCustomNV& setSampleCount( uint32_t sampleCount_ )
{
- format = format_;
+ sampleCount = sampleCount_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ )
+ CoarseSampleOrderCustomNV& setSampleLocationCount( uint32_t sampleLocationCount_ )
{
- ycbcrModel = ycbcrModel_;
+ sampleLocationCount = sampleLocationCount_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setYcbcrRange( SamplerYcbcrRange ycbcrRange_ )
+ CoarseSampleOrderCustomNV& setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ )
{
- ycbcrRange = ycbcrRange_;
+ pSampleLocations = pSampleLocations_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setComponents( ComponentMapping components_ )
+ operator VkCoarseSampleOrderCustomNV const&() const
{
- components = components_;
- return *this;
+ return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>(this);
}
- SamplerYcbcrConversionCreateInfo& setXChromaOffset( ChromaLocation xChromaOffset_ )
+ operator VkCoarseSampleOrderCustomNV &()
{
- xChromaOffset = xChromaOffset_;
+ return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this);
+ }
+
+ bool operator==( CoarseSampleOrderCustomNV const& rhs ) const
+ {
+ return ( shadingRate == rhs.shadingRate )
+ && ( sampleCount == rhs.sampleCount )
+ && ( sampleLocationCount == rhs.sampleLocationCount )
+ && ( pSampleLocations == rhs.pSampleLocations );
+ }
+
+ bool operator!=( CoarseSampleOrderCustomNV const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ ShadingRatePaletteEntryNV shadingRate;
+ uint32_t sampleCount;
+ uint32_t sampleLocationCount;
+ const CoarseSampleLocationNV* pSampleLocations;
+ };
+ static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
+
+ enum class CoarseSampleOrderTypeNV
+ {
+ eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
+ eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
+ ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
+ eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
+ };
+
+ struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+ {
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault,
+ uint32_t customSampleOrderCount_ = 0,
+ const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+ : sampleOrderType( sampleOrderType_ )
+ , customSampleOrderCount( customSampleOrderCount_ )
+ , pCustomSampleOrders( pCustomSampleOrders_ )
+ {
+ }
+
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+ }
+
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+ return *this;
+ }
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setYChromaOffset( ChromaLocation yChromaOffset_ )
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV& setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ )
{
- yChromaOffset = yChromaOffset_;
+ sampleOrderType = sampleOrderType_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setChromaFilter( Filter chromaFilter_ )
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV& setCustomSampleOrderCount( uint32_t customSampleOrderCount_ )
{
- chromaFilter = chromaFilter_;
+ customSampleOrderCount = customSampleOrderCount_;
return *this;
}
- SamplerYcbcrConversionCreateInfo& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV& setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
{
- forceExplicitReconstruction = forceExplicitReconstruction_;
+ pCustomSampleOrders = pCustomSampleOrders_;
return *this;
}
- operator const VkSamplerYcbcrConversionCreateInfo&() const
+ operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const
{
- return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(this);
+ return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
}
- bool operator==( SamplerYcbcrConversionCreateInfo const& rhs ) const
+ operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
+ }
+
+ bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( format == rhs.format )
- && ( ycbcrModel == rhs.ycbcrModel )
- && ( ycbcrRange == rhs.ycbcrRange )
- && ( components == rhs.components )
- && ( xChromaOffset == rhs.xChromaOffset )
- && ( yChromaOffset == rhs.yChromaOffset )
- && ( chromaFilter == rhs.chromaFilter )
- && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction );
+ && ( sampleOrderType == rhs.sampleOrderType )
+ && ( customSampleOrderCount == rhs.customSampleOrderCount )
+ && ( pCustomSampleOrders == rhs.pCustomSampleOrders );
}
- bool operator!=( SamplerYcbcrConversionCreateInfo const& rhs ) const
+ bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
+ StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
public:
const void* pNext = nullptr;
- Format format;
- SamplerYcbcrModelConversion ycbcrModel;
- SamplerYcbcrRange ycbcrRange;
- ComponentMapping components;
- ChromaLocation xChromaOffset;
- ChromaLocation yChromaOffset;
- Filter chromaFilter;
- Bool32 forceExplicitReconstruction;
+ CoarseSampleOrderTypeNV sampleOrderType;
+ uint32_t customSampleOrderCount;
+ const CoarseSampleOrderCustomNV* pCustomSampleOrders;
};
- static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
- using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
+ enum class GeometryInstanceFlagBitsNV
+ {
+ eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV,
+ eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV,
+ eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV,
+ eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV
+ };
-#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
- struct AndroidHardwareBufferFormatPropertiesANDROID
+ using GeometryInstanceFlagsNV = Flags<GeometryInstanceFlagBitsNV, VkGeometryInstanceFlagsNV>;
+
+ VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+ {
+ return GeometryInstanceFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits )
+ {
+ return ~( GeometryInstanceFlagsNV( bits ) );
+ }
+
+ template <> struct FlagTraits<GeometryInstanceFlagBitsNV>
{
- operator const VkAndroidHardwareBufferFormatPropertiesANDROID&() const
+ enum
{
- return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
- }
+ allFlags = VkFlags(GeometryInstanceFlagBitsNV::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) | VkFlags(GeometryInstanceFlagBitsNV::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNV::eForceNoOpaque)
+ };
+ };
- bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
+ enum class GeometryFlagBitsNV
+ {
+ eOpaque = VK_GEOMETRY_OPAQUE_BIT_NV,
+ eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV
+ };
+
+ using GeometryFlagsNV = Flags<GeometryFlagBitsNV, VkGeometryFlagsNV>;
+
+ VULKAN_HPP_INLINE GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+ {
+ return GeometryFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE GeometryFlagsNV operator~( GeometryFlagBitsNV bits )
+ {
+ return ~( GeometryFlagsNV( bits ) );
+ }
+
+ template <> struct FlagTraits<GeometryFlagBitsNV>
+ {
+ enum
{
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( format == rhs.format )
- && ( externalFormat == rhs.externalFormat )
- && ( formatFeatures == rhs.formatFeatures )
- && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents )
- && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel )
- && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange )
- && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset )
- && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
- }
+ allFlags = VkFlags(GeometryFlagBitsNV::eOpaque) | VkFlags(GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation)
+ };
+ };
- bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
+ enum class BuildAccelerationStructureFlagBitsNV
+ {
+ eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV,
+ eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV,
+ ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV,
+ ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV,
+ eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV
+ };
+
+ using BuildAccelerationStructureFlagsNV = Flags<BuildAccelerationStructureFlagBitsNV, VkBuildAccelerationStructureFlagsNV>;
+
+ VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+ {
+ return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits )
+ {
+ return ~( BuildAccelerationStructureFlagsNV( bits ) );
+ }
+
+ template <> struct FlagTraits<BuildAccelerationStructureFlagBitsNV>
+ {
+ enum
{
- return !operator==( rhs );
- }
+ allFlags = VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNV::eLowMemory)
+ };
+ };
- private:
- StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
+ enum class CopyAccelerationStructureModeNV
+ {
+ eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV,
+ eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV
+ };
- public:
- void* pNext = nullptr;
- Format format;
- uint64_t externalFormat;
- FormatFeatureFlags formatFeatures;
- ComponentMapping samplerYcbcrConversionComponents;
- SamplerYcbcrModelConversion suggestedYcbcrModel;
- SamplerYcbcrRange suggestedYcbcrRange;
- ChromaLocation suggestedXChromaOffset;
- ChromaLocation suggestedYChromaOffset;
+ enum class AccelerationStructureTypeNV
+ {
+ eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
+ eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV
};
- static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
- enum class BlendOverlapEXT
+ enum class GeometryTypeNV
{
- eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
- eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
- eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
+ eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV,
+ eAabbs = VK_GEOMETRY_TYPE_AABBS_NV
};
- struct PipelineColorBlendAdvancedStateCreateInfoEXT
+ struct GeometryNV
{
- PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0,
- Bool32 dstPremultiplied_ = 0,
- BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
- : srcPremultiplied( srcPremultiplied_ )
- , dstPremultiplied( dstPremultiplied_ )
- , blendOverlap( blendOverlap_ )
+ GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles,
+ GeometryDataNV geometry_ = GeometryDataNV(),
+ GeometryFlagsNV flags_ = GeometryFlagsNV() )
+ : geometryType( geometryType_ )
+ , geometry( geometry_ )
+ , flags( flags_ )
{
}
- PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+ GeometryNV( VkGeometryNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( GeometryNV ) );
}
- PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+ GeometryNV& operator=( VkGeometryNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( GeometryNV ) );
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ )
+ GeometryNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ )
+ GeometryNV& setGeometryType( GeometryTypeNV geometryType_ )
{
- srcPremultiplied = srcPremultiplied_;
+ geometryType = geometryType_;
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ )
+ GeometryNV& setGeometry( GeometryDataNV geometry_ )
{
- dstPremultiplied = dstPremultiplied_;
+ geometry = geometry_;
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ )
+ GeometryNV& setFlags( GeometryFlagsNV flags_ )
{
- blendOverlap = blendOverlap_;
+ flags = flags_;
return *this;
}
- operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const
+ operator VkGeometryNV const&() const
{
- return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
+ return *reinterpret_cast<const VkGeometryNV*>(this);
}
- bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
+ operator VkGeometryNV &()
+ {
+ return *reinterpret_cast<VkGeometryNV*>(this);
+ }
+
+ bool operator==( GeometryNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( srcPremultiplied == rhs.srcPremultiplied )
- && ( dstPremultiplied == rhs.dstPremultiplied )
- && ( blendOverlap == rhs.blendOverlap );
+ && ( geometryType == rhs.geometryType )
+ && ( geometry == rhs.geometry )
+ && ( flags == rhs.flags );
}
- bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
+ bool operator!=( GeometryNV const& rhs ) const
{
return !operator==( rhs );
}
- private:
- StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Bool32 srcPremultiplied;
- Bool32 dstPremultiplied;
- BlendOverlapEXT blendOverlap;
- };
- static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
- enum class CoverageModulationModeNV
- {
- eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
- eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
- eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
- eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
+ private:
+ StructureType sType = StructureType::eGeometryNV;
+
+ public:
+ const void* pNext = nullptr;
+ GeometryTypeNV geometryType;
+ GeometryDataNV geometry;
+ GeometryFlagsNV flags;
};
+ static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
- struct PipelineCoverageModulationStateCreateInfoNV
+ struct AccelerationStructureInfoNV
{
- PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(),
- CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone,
- Bool32 coverageModulationTableEnable_ = 0,
- uint32_t coverageModulationTableCount_ = 0,
- const float* pCoverageModulationTable_ = nullptr )
- : flags( flags_ )
- , coverageModulationMode( coverageModulationMode_ )
- , coverageModulationTableEnable( coverageModulationTableEnable_ )
- , coverageModulationTableCount( coverageModulationTableCount_ )
- , pCoverageModulationTable( pCoverageModulationTable_ )
+ AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel,
+ BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(),
+ uint32_t instanceCount_ = 0,
+ uint32_t geometryCount_ = 0,
+ const GeometryNV* pGeometries_ = nullptr )
+ : type( type_ )
+ , flags( flags_ )
+ , instanceCount( instanceCount_ )
+ , geometryCount( geometryCount_ )
+ , pGeometries( pGeometries_ )
{
}
- PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+ AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
+ memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
}
- PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+ AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
+ memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ )
+ AccelerationStructureInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
+ AccelerationStructureInfoNV& setType( AccelerationStructureTypeNV type_ )
{
- flags = flags_;
+ type = type_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
+ AccelerationStructureInfoNV& setFlags( BuildAccelerationStructureFlagsNV flags_ )
{
- coverageModulationMode = coverageModulationMode_;
+ flags = flags_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
+ AccelerationStructureInfoNV& setInstanceCount( uint32_t instanceCount_ )
{
- coverageModulationTableEnable = coverageModulationTableEnable_;
+ instanceCount = instanceCount_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ )
+ AccelerationStructureInfoNV& setGeometryCount( uint32_t geometryCount_ )
{
- coverageModulationTableCount = coverageModulationTableCount_;
+ geometryCount = geometryCount_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ )
+ AccelerationStructureInfoNV& setPGeometries( const GeometryNV* pGeometries_ )
{
- pCoverageModulationTable = pCoverageModulationTable_;
+ pGeometries = pGeometries_;
return *this;
}
- operator const VkPipelineCoverageModulationStateCreateInfoNV&() const
+ operator VkAccelerationStructureInfoNV const&() const
{
- return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this);
+ return *reinterpret_cast<const VkAccelerationStructureInfoNV*>(this);
}
- bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
+ operator VkAccelerationStructureInfoNV &()
+ {
+ return *reinterpret_cast<VkAccelerationStructureInfoNV*>(this);
+ }
+
+ bool operator==( AccelerationStructureInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
+ && ( type == rhs.type )
&& ( flags == rhs.flags )
- && ( coverageModulationMode == rhs.coverageModulationMode )
- && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable )
- && ( coverageModulationTableCount == rhs.coverageModulationTableCount )
- && ( pCoverageModulationTable == rhs.pCoverageModulationTable );
+ && ( instanceCount == rhs.instanceCount )
+ && ( geometryCount == rhs.geometryCount )
+ && ( pGeometries == rhs.pGeometries );
}
- bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
+ bool operator!=( AccelerationStructureInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
+ StructureType sType = StructureType::eAccelerationStructureInfoNV;
public:
const void* pNext = nullptr;
- PipelineCoverageModulationStateCreateFlagsNV flags;
- CoverageModulationModeNV coverageModulationMode;
- Bool32 coverageModulationTableEnable;
- uint32_t coverageModulationTableCount;
- const float* pCoverageModulationTable;
- };
- static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
-
- enum class ValidationCacheHeaderVersionEXT
- {
- eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
- };
-
- enum class ShaderInfoTypeAMD
- {
- eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
- eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
- eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
- };
-
- enum class QueueGlobalPriorityEXT
- {
- eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
- eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
- eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
- eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
+ AccelerationStructureTypeNV type;
+ BuildAccelerationStructureFlagsNV flags;
+ uint32_t instanceCount;
+ uint32_t geometryCount;
+ const GeometryNV* pGeometries;
};
+ static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" );
- struct DeviceQueueGlobalPriorityCreateInfoEXT
+ struct AccelerationStructureCreateInfoNV
{
- DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
- : globalPriority( globalPriority_ )
+ AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0,
+ AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() )
+ : compactedSize( compactedSize_ )
+ , info( info_ )
{
}
- DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+ AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
}
- DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+ AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
return *this;
}
- DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ )
+ AccelerationStructureCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
+ AccelerationStructureCreateInfoNV& setCompactedSize( DeviceSize compactedSize_ )
{
- globalPriority = globalPriority_;
+ compactedSize = compactedSize_;
return *this;
}
- operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const
+ AccelerationStructureCreateInfoNV& setInfo( AccelerationStructureInfoNV info_ )
{
- return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
+ info = info_;
+ return *this;
}
- bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
+ operator VkAccelerationStructureCreateInfoNV const&() const
+ {
+ return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(this);
+ }
+
+ operator VkAccelerationStructureCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this);
+ }
+
+ bool operator==( AccelerationStructureCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( globalPriority == rhs.globalPriority );
+ && ( compactedSize == rhs.compactedSize )
+ && ( info == rhs.info );
}
- bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
+ bool operator!=( AccelerationStructureCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
+ StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
public:
const void* pNext = nullptr;
- QueueGlobalPriorityEXT globalPriority;
- };
- static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
-
- enum class DebugUtilsMessageSeverityFlagBitsEXT
- {
- eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
- eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
- eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
- eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
- };
-
- using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageSeverityFlagsEXT>;
-
- VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
- {
- return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits )
- {
- return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) );
- }
-
- template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT>
- {
- enum
- {
- allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError)
- };
+ DeviceSize compactedSize;
+ AccelerationStructureInfoNV info;
};
+ static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
- enum class DebugUtilsMessageTypeFlagBitsEXT
- {
- eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
- eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
- ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
- };
-
- using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT>;
-
- VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
- {
- return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits )
- {
- return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
- }
-
- template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT>
+ enum class AccelerationStructureMemoryRequirementsTypeNV
{
- enum
- {
- allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
- };
+ eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
+ eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
+ eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
};
- struct DebugUtilsMessengerCreateInfoEXT
+ struct AccelerationStructureMemoryRequirementsInfoNV
{
- DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(),
- DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(),
- DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(),
- PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
- void* pUserData_ = nullptr )
- : flags( flags_ )
- , messageSeverity( messageSeverity_ )
- , messageType( messageType_ )
- , pfnUserCallback( pfnUserCallback_ )
- , pUserData( pUserData_ )
+ AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject,
+ AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() )
+ : type( type_ )
+ , accelerationStructure( accelerationStructure_ )
{
}
- DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+ AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
}
- DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+ AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
return *this;
}
- DebugUtilsMessengerCreateInfoEXT& setPNext( const void* pNext_ )
+ AccelerationStructureMemoryRequirementsInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- DebugUtilsMessengerCreateInfoEXT& setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ )
- {
- flags = flags_;
- return *this;
- }
-
- DebugUtilsMessengerCreateInfoEXT& setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
- {
- messageSeverity = messageSeverity_;
- return *this;
- }
-
- DebugUtilsMessengerCreateInfoEXT& setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ )
+ AccelerationStructureMemoryRequirementsInfoNV& setType( AccelerationStructureMemoryRequirementsTypeNV type_ )
{
- messageType = messageType_;
+ type = type_;
return *this;
}
- DebugUtilsMessengerCreateInfoEXT& setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ )
+ AccelerationStructureMemoryRequirementsInfoNV& setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
{
- pfnUserCallback = pfnUserCallback_;
+ accelerationStructure = accelerationStructure_;
return *this;
}
- DebugUtilsMessengerCreateInfoEXT& setPUserData( void* pUserData_ )
+ operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const
{
- pUserData = pUserData_;
- return *this;
+ return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
}
- operator const VkDebugUtilsMessengerCreateInfoEXT&() const
+ operator VkAccelerationStructureMemoryRequirementsInfoNV &()
{
- return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(this);
+ return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
}
- bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
+ bool operator==( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( messageSeverity == rhs.messageSeverity )
- && ( messageType == rhs.messageType )
- && ( pfnUserCallback == rhs.pfnUserCallback )
- && ( pUserData == rhs.pUserData );
+ && ( type == rhs.type )
+ && ( accelerationStructure == rhs.accelerationStructure );
}
- bool operator!=( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
+ bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
+ StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
public:
const void* pNext = nullptr;
- DebugUtilsMessengerCreateFlagsEXT flags;
- DebugUtilsMessageSeverityFlagsEXT messageSeverity;
- DebugUtilsMessageTypeFlagsEXT messageType;
- PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
- void* pUserData;
+ AccelerationStructureMemoryRequirementsTypeNV type;
+ AccelerationStructureNV accelerationStructure;
};
- static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
- enum class ConservativeRasterizationModeEXT
+ enum class RayTracingShaderGroupTypeNV
{
- eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
- eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
- eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
+ eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,
+ eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV,
+ eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV
};
- struct PipelineRasterizationConservativeStateCreateInfoEXT
+ struct RayTracingShaderGroupCreateInfoNV
{
- PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(),
- ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled,
- float extraPrimitiveOverestimationSize_ = 0 )
- : flags( flags_ )
- , conservativeRasterizationMode( conservativeRasterizationMode_ )
- , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+ RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral,
+ uint32_t generalShader_ = 0,
+ uint32_t closestHitShader_ = 0,
+ uint32_t anyHitShader_ = 0,
+ uint32_t intersectionShader_ = 0 )
+ : type( type_ )
+ , generalShader( generalShader_ )
+ , closestHitShader( closestHitShader_ )
+ , anyHitShader( anyHitShader_ )
+ , intersectionShader( intersectionShader_ )
{
}
- PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+ RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
}
- PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+ RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+ memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
return *this;
}
- PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ )
+ RayTracingShaderGroupCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
+ RayTracingShaderGroupCreateInfoNV& setType( RayTracingShaderGroupTypeNV type_ )
{
- flags = flags_;
+ type = type_;
return *this;
}
- PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
+ RayTracingShaderGroupCreateInfoNV& setGeneralShader( uint32_t generalShader_ )
{
- conservativeRasterizationMode = conservativeRasterizationMode_;
+ generalShader = generalShader_;
return *this;
}
- PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ )
+ RayTracingShaderGroupCreateInfoNV& setClosestHitShader( uint32_t closestHitShader_ )
{
- extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
+ closestHitShader = closestHitShader_;
return *this;
}
- operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const
+ RayTracingShaderGroupCreateInfoNV& setAnyHitShader( uint32_t anyHitShader_ )
{
- return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
+ anyHitShader = anyHitShader_;
+ return *this;
}
- bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
+ RayTracingShaderGroupCreateInfoNV& setIntersectionShader( uint32_t intersectionShader_ )
+ {
+ intersectionShader = intersectionShader_;
+ return *this;
+ }
+
+ operator VkRayTracingShaderGroupCreateInfoNV const&() const
+ {
+ return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(this);
+ }
+
+ operator VkRayTracingShaderGroupCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this);
+ }
+
+ bool operator==( RayTracingShaderGroupCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( flags == rhs.flags )
- && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode )
- && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
+ && ( type == rhs.type )
+ && ( generalShader == rhs.generalShader )
+ && ( closestHitShader == rhs.closestHitShader )
+ && ( anyHitShader == rhs.anyHitShader )
+ && ( intersectionShader == rhs.intersectionShader );
}
- bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
+ bool operator!=( RayTracingShaderGroupCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+ StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
public:
const void* pNext = nullptr;
- PipelineRasterizationConservativeStateCreateFlagsEXT flags;
- ConservativeRasterizationModeEXT conservativeRasterizationMode;
- float extraPrimitiveOverestimationSize;
- };
- static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ RayTracingShaderGroupTypeNV type;
+ uint32_t generalShader;
+ uint32_t closestHitShader;
+ uint32_t anyHitShader;
+ uint32_t intersectionShader;
+ };
+ static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
+
+ struct RayTracingPipelineCreateInfoNV
+ {
+ RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+ uint32_t stageCount_ = 0,
+ const PipelineShaderStageCreateInfo* pStages_ = nullptr,
+ uint32_t groupCount_ = 0,
+ const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
+ uint32_t maxRecursionDepth_ = 0,
+ PipelineLayout layout_ = PipelineLayout(),
+ Pipeline basePipelineHandle_ = Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : flags( flags_ )
+ , stageCount( stageCount_ )
+ , pStages( pStages_ )
+ , groupCount( groupCount_ )
+ , pGroups( pGroups_ )
+ , maxRecursionDepth( maxRecursionDepth_ )
+ , layout( layout_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
+ {
+ }
- enum class DescriptorBindingFlagBitsEXT
- {
- eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
- eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT,
- ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT,
- eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT
- };
+ RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
+ }
- using DescriptorBindingFlagsEXT = Flags<DescriptorBindingFlagBitsEXT, VkDescriptorBindingFlagsEXT>;
+ RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
+ return *this;
+ }
+ RayTracingPipelineCreateInfoNV& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
- VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
- {
- return DescriptorBindingFlagsEXT( bit0 ) | bit1;
- }
+ RayTracingPipelineCreateInfoNV& setFlags( PipelineCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
- VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits )
- {
- return ~( DescriptorBindingFlagsEXT( bits ) );
- }
+ RayTracingPipelineCreateInfoNV& setStageCount( uint32_t stageCount_ )
+ {
+ stageCount = stageCount_;
+ return *this;
+ }
- template <> struct FlagTraits<DescriptorBindingFlagBitsEXT>
- {
- enum
+ RayTracingPipelineCreateInfoNV& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
{
- allFlags = VkFlags(DescriptorBindingFlagBitsEXT::eUpdateAfterBind) | VkFlags(DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) | VkFlags(DescriptorBindingFlagBitsEXT::ePartiallyBound) | VkFlags(DescriptorBindingFlagBitsEXT::eVariableDescriptorCount)
- };
- };
+ pStages = pStages_;
+ return *this;
+ }
- struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
- {
- DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
- const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
- : bindingCount( bindingCount_ )
- , pBindingFlags( pBindingFlags_ )
+ RayTracingPipelineCreateInfoNV& setGroupCount( uint32_t groupCount_ )
{
+ groupCount = groupCount_;
+ return *this;
}
- DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+ RayTracingPipelineCreateInfoNV& setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
+ pGroups = pGroups_;
+ return *this;
}
- DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+ RayTracingPipelineCreateInfoNV& setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
+ maxRecursionDepth = maxRecursionDepth_;
return *this;
}
- DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPNext( const void* pNext_ )
+
+ RayTracingPipelineCreateInfoNV& setLayout( PipelineLayout layout_ )
{
- pNext = pNext_;
+ layout = layout_;
return *this;
}
- DescriptorSetLayoutBindingFlagsCreateInfoEXT& setBindingCount( uint32_t bindingCount_ )
+ RayTracingPipelineCreateInfoNV& setBasePipelineHandle( Pipeline basePipelineHandle_ )
{
- bindingCount = bindingCount_;
+ basePipelineHandle = basePipelineHandle_;
return *this;
}
- DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ )
+ RayTracingPipelineCreateInfoNV& setBasePipelineIndex( int32_t basePipelineIndex_ )
{
- pBindingFlags = pBindingFlags_;
+ basePipelineIndex = basePipelineIndex_;
return *this;
}
- operator const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT&() const
+ operator VkRayTracingPipelineCreateInfoNV const&() const
{
- return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
+ return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(this);
}
- bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
+ operator VkRayTracingPipelineCreateInfoNV &()
+ {
+ return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this);
+ }
+
+ bool operator==( RayTracingPipelineCreateInfoNV const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( bindingCount == rhs.bindingCount )
- && ( pBindingFlags == rhs.pBindingFlags );
+ && ( flags == rhs.flags )
+ && ( stageCount == rhs.stageCount )
+ && ( pStages == rhs.pStages )
+ && ( groupCount == rhs.groupCount )
+ && ( pGroups == rhs.pGroups )
+ && ( maxRecursionDepth == rhs.maxRecursionDepth )
+ && ( layout == rhs.layout )
+ && ( basePipelineHandle == rhs.basePipelineHandle )
+ && ( basePipelineIndex == rhs.basePipelineIndex );
}
- bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
+ bool operator!=( RayTracingPipelineCreateInfoNV const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+ StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
public:
const void* pNext = nullptr;
- uint32_t bindingCount;
- const DescriptorBindingFlagsEXT* pBindingFlags;
- };
- static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
-
- enum class VendorId
- {
- eViv = VK_VENDOR_ID_VIV,
- eVsi = VK_VENDOR_ID_VSI,
- eKazan = VK_VENDOR_ID_KAZAN
- };
-
- enum class ConditionalRenderingFlagBitsEXT
- {
- eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
+ PipelineCreateFlags flags;
+ uint32_t stageCount;
+ const PipelineShaderStageCreateInfo* pStages;
+ uint32_t groupCount;
+ const RayTracingShaderGroupCreateInfoNV* pGroups;
+ uint32_t maxRecursionDepth;
+ PipelineLayout layout;
+ Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
};
+ static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" );
- using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT, VkConditionalRenderingFlagsEXT>;
-
- VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
- {
- return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits )
- {
- return ~( ConditionalRenderingFlagsEXT( bits ) );
- }
-
- template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT>
+ enum class MemoryOverallocationBehaviorAMD
{
- enum
- {
- allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted)
- };
+ eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
+ eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
+ eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
};
- struct ConditionalRenderingBeginInfoEXT
+ struct DeviceMemoryOverallocationCreateInfoAMD
{
- ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0,
- ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() )
- : buffer( buffer_ )
- , offset( offset_ )
- , flags( flags_ )
+ DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault )
+ : overallocationBehavior( overallocationBehavior_ )
{
}
- ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
+ DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
+ memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
}
- ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
+ DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
+ memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
return *this;
}
- ConditionalRenderingBeginInfoEXT& setPNext( const void* pNext_ )
+ DeviceMemoryOverallocationCreateInfoAMD& setPNext( const void* pNext_ )
{
pNext = pNext_;
return *this;
}
- ConditionalRenderingBeginInfoEXT& setBuffer( Buffer buffer_ )
- {
- buffer = buffer_;
- return *this;
- }
-
- ConditionalRenderingBeginInfoEXT& setOffset( DeviceSize offset_ )
+ DeviceMemoryOverallocationCreateInfoAMD& setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ )
{
- offset = offset_;
+ overallocationBehavior = overallocationBehavior_;
return *this;
}
- ConditionalRenderingBeginInfoEXT& setFlags( ConditionalRenderingFlagsEXT flags_ )
+ operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const
{
- flags = flags_;
- return *this;
+ return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(this);
}
- operator const VkConditionalRenderingBeginInfoEXT&() const
+ operator VkDeviceMemoryOverallocationCreateInfoAMD &()
{
- return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(this);
+ return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this);
}
- bool operator==( ConditionalRenderingBeginInfoEXT const& rhs ) const
+ bool operator==( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( buffer == rhs.buffer )
- && ( offset == rhs.offset )
- && ( flags == rhs.flags );
+ && ( overallocationBehavior == rhs.overallocationBehavior );
}
- bool operator!=( ConditionalRenderingBeginInfoEXT const& rhs ) const
+ bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
+ StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
public:
const void* pNext = nullptr;
- Buffer buffer;
- DeviceSize offset;
- ConditionalRenderingFlagsEXT flags;
+ MemoryOverallocationBehaviorAMD overallocationBehavior;
};
- static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" );
template<typename Dispatch = DispatchLoaderStatic>
Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() );
+ template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d )
+ {
+ std::vector<LayerProperties,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() );
+ template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d )
+ {
+ std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
+ void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const;
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const
+ {
+ d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets, pSizes );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d ) const
+ {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+#else
+ if ( buffers.size() != offsets.size() )
+ {
+ throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
+ }
+#endif // VULKAN_HPP_NO_EXCEPTIONS
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
+#else
+ if ( buffers.size() != sizes.size() )
+ {
+ throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
+ }
+#endif // VULKAN_HPP_NO_EXCEPTIONS
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
+#else
+ if ( offsets.size() != sizes.size() )
+ {
+ throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" );
+ }
+#endif // VULKAN_HPP_NO_EXCEPTIONS
+ d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data(), sizes.data() );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+ {
+ d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), pCounterBufferOffsets );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+ {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
+#else
+ if ( counterBuffers.size() != counterBufferOffsets.size() )
+ {
+ throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+ }
+#endif // VULKAN_HPP_NO_EXCEPTIONS
+ d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), counterBufferOffsets.data() );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+ {
+ d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), pCounterBufferOffsets );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+ {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
+#else
+ if ( counterBuffers.size() != counterBufferOffsets.size() )
+ {
+ throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+ }
+#endif // VULKAN_HPP_NO_EXCEPTIONS
+ d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), counterBufferOffsets.data() );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d) const
+ {
+ d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
+ {
+ d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
+ {
+ d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
+ {
+ d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
+ {
+ d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), counterBufferOffset, counterOffset, vertexStride );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
+ {
+ d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), counterBufferOffset, counterOffset, vertexStride );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
+ {
+ d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
+ {
+ d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
+ {
+ d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
+ {
+ d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
+ {
+ d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
+ {
+ d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
+ {
+ d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
+ {
+ d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d) const
+ {
+ d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d ) const
+ {
+ d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+ {
+ d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+ {
+ d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+ {
+ d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+ {
+ d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const
+ {
+ d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
+ {
+ d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const
+ {
+ d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureNV*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const
+ {
+ d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureNV*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const
+ {
+ d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( pInfo ), static_cast<VkBuffer>( instanceData ), instanceOffset, update, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const
+ {
+ d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( &info ), static_cast<VkBuffer>( instanceData ), instanceOffset, update, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
+ {
+ d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast<VkBuffer>( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
+ {
+ d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast<VkBuffer>( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
struct SubmitInfo
{
SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
return *this;
}
- operator const VkSubmitInfo&() const
+ operator VkSubmitInfo const&() const
{
return *reinterpret_cast<const VkSubmitInfo*>(this);
}
+ operator VkSubmitInfo &()
+ {
+ return *reinterpret_cast<VkSubmitInfo*>(this);
+ }
+
bool operator==( SubmitInfo const& rhs ) const
{
return ( sType == rhs.sType )
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic>
std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
return checkpointData;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<CheckpointDataNV,Allocator> checkpointData( vectorAllocator );
+ uint32_t checkpointDataCount;
+ d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
+ checkpointData.resize( checkpointDataCount );
+ d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
+ return checkpointData;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Device;
+ template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
+ using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV,DispatchLoaderStatic>;
template <typename Dispatch> class UniqueHandleTraits<Buffer,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
using UniqueBuffer = UniqueHandle<Buffer,DispatchLoaderStatic>;
template <typename Dispatch> class UniqueHandleTraits<BufferView,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic>
std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
template <typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- typename ResultValueType<StructureChain<T...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+#else
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<void>::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ void destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename T, typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename T, typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<void>::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<Pipeline>::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
return sparseMemoryRequirements;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements( vectorAllocator );
+ uint32_t sparseMemoryRequirementCount;
+ d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
+ sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+ d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
+ return sparseMemoryRequirements;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( dataSize <= data.size() );
- data.resize( dataSize );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( dataSize <= data.size() );
+ data.resize( dataSize );
+ }
+ return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<uint8_t,Allocator> data( vectorAllocator );
+ size_t dataSize;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
+ if ( ( result == Result::eSuccess ) && dataSize )
+ {
+ data.resize( dataSize );
+ result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( dataSize <= data.size() );
+ data.resize( dataSize );
+ }
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
}
template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
+ Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
+ }
+ template<typename Dispatch>
VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
}
template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
+ std::vector<UniquePipeline, Allocator> pipelines;
+ pipelines.reserve( createInfos.size() );
+ Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
+ Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ for ( size_t i=0 ; i<createInfos.size() ; i++ )
+ {
+ pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
+ }
+ template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
}
template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
+ Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
+ }
+ template<typename Dispatch>
VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
}
template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
+ std::vector<UniquePipeline, Allocator> pipelines;
+ pipelines.reserve( createInfos.size() );
+ Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
+ Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ for ( size_t i=0 ; i<createInfos.size() ; i++ )
+ {
+ pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
+ }
+ template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount, vectorAllocator );
+ Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
+ return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
+ }
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const
return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" );
+ std::vector<UniqueDescriptorSet, Allocator> descriptorSets;
+ descriptorSets.reserve( allocateInfo.descriptorSetCount );
+ DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) );
+ Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
+
+ PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
+ for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
+ {
+ descriptorSets.push_back( UniqueDescriptorSet( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
+ }
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount, vectorAllocator );
+ Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
+ return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
+ }
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Allocator, typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const
return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" );
+ std::vector<UniqueCommandBuffer, Allocator> commandBuffers;
+ commandBuffers.reserve( allocateInfo.commandBufferCount );
+ CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) );
+ Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
+
+ PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
+ for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
+ {
+ commandBuffers.push_back( UniqueCommandBuffer( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+ }
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
}
template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size(), vectorAllocator );
+ Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
+ return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
+ }
+ template<typename Dispatch>
VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
SwapchainKHR swapchain;
return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
}
template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" );
+ std::vector<UniqueSwapchainKHR, Allocator> swapchainKHRs;
+ swapchainKHRs.reserve( createInfos.size() );
+ SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) );
+ Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ for ( size_t i=0 ; i<createInfos.size() ; i++ )
+ {
+ swapchainKHRs.push_back( UniqueSwapchainKHR( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+ }
+ template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
SwapchainKHR swapchain;
result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
- swapchainImages.resize( swapchainImageCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+ swapchainImages.resize( swapchainImageCount );
+ }
+ return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<Image,Allocator> swapchainImages( vectorAllocator );
+ uint32_t swapchainImageCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && swapchainImageCount )
+ {
+ swapchainImages.resize( swapchainImageCount );
+ result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+ swapchainImages.resize( swapchainImageCount );
+ }
return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
- presentationTimings.resize( presentationTimingCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+ presentationTimings.resize( presentationTimingCount );
+ }
+ return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings( vectorAllocator );
+ uint32_t presentationTimingCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && presentationTimingCount )
+ {
+ presentationTimings.resize( presentationTimingCount );
+ result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+ presentationTimings.resize( presentationTimingCount );
+ }
return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
return sparseMemoryRequirements;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
+ uint32_t sparseMemoryRequirementCount;
+ d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+ sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+ d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+ return sparseMemoryRequirements;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
return sparseMemoryRequirements;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
+ uint32_t sparseMemoryRequirementCount;
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+ sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+ d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+ return sparseMemoryRequirements;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( dataSize <= data.size() );
- data.resize( dataSize );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( dataSize <= data.size() );
+ data.resize( dataSize );
+ }
+ return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<uint8_t,Allocator> data( vectorAllocator );
+ size_t dataSize;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
+ if ( ( result == Result::eSuccess ) && dataSize )
+ {
+ data.resize( dataSize );
+ result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( dataSize <= data.size() );
+ data.resize( dataSize );
+ }
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return support;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return structureChain;
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return support;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return structureChain;
result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, reinterpret_cast<void*>( info.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( infoSize <= info.size() );
- info.resize( infoSize );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( infoSize <= info.size() );
+ info.resize( infoSize );
+ }
return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<uint8_t,Allocator> info( vectorAllocator );
+ size_t infoSize;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, nullptr ) );
+ if ( ( result == Result::eSuccess ) && infoSize )
+ {
+ info.resize( infoSize );
+ result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, reinterpret_cast<void*>( info.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( infoSize <= info.size() );
+ info.resize( infoSize );
+ }
+ return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
+ {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+ VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
+#else
+ if ( timestampInfos.size() != timestamps.size() )
+ {
+ throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
+ }
+#endif // VULKAN_HPP_NO_EXCEPTIONS
+ uint64_t maxDeviation;
+ Result result = static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size() , reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
+ return createResultValue( result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING"::Device::getCalibratedTimestampsEXT" );
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNV*>( pAccelerationStructure ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ AccelerationStructureNV accelerationStructure;
+ Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
+ return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" );
+ }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ AccelerationStructureNV accelerationStructure;
+ Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ return createResultValue<AccelerationStructureNV,Dispatch>( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVUnique", deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ {
+ d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ {
+ d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
+ {
+ d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
+ {
+ MemoryRequirements2KHR memoryRequirements;
+ d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
+ return memoryRequirements;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( pBindInfos ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( bindInfos.data() ) ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename T, typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename T, typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
+ }
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ Pipeline pipeline;
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+ return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNV" );
+ }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
+ std::vector<UniquePipeline, Allocator> pipelines;
+ pipelines.reserve( createInfos.size() );
+ Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
+ Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ for ( size_t i=0 ; i<createInfos.size() ; i++ )
+ {
+ pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
+ std::vector<UniquePipeline, Allocator> pipelines;
+ pipelines.reserve( createInfos.size() );
+ Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
+ Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ for ( size_t i=0 ; i<createInfos.size() ; i++ )
+ {
+ pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
+ }
+
+ return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
+ }
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ Pipeline pipeline;
+ Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNVUnique", deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( pProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d ) const
+ {
+ ImageDrmFormatModifierPropertiesEXT properties;
+ Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( &properties ) ) );
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch> class UniqueHandleTraits<Device,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getProperties(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic>
std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic>
std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- template<typename Dispatch = DispatchLoaderStatic>
- Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderStatic>
- Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
template<typename Dispatch = DispatchLoaderStatic>
Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getFeatures2(Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getProperties2(Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- StructureChain<T...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ StructureChain<X, Y, Z...> getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- typename ResultValueType<StructureChain<T...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- typename ResultValueType<StructureChain<T...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
+ std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
- template <typename ...T, typename Dispatch = DispatchLoaderStatic>
- typename ResultValueType<StructureChain<T...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
ResultValueType<DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
return properties;
}
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties(Dispatch const &d ) const
+ {
+ StructureChain<X, Y, Z...> structureChain;
+ PhysicalDeviceProperties& properties = structureChain.template get<PhysicalDeviceProperties>();
+ d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
+ return structureChain;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
return queueFamilyProperties;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties( vectorAllocator );
+ uint32_t queueFamilyPropertyCount;
+ d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ queueFamilyProperties.resize( queueFamilyPropertyCount );
+ d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
+ return queueFamilyProperties;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<LayerProperties,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
return properties;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SparseImageFormatProperties,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
+ properties.resize( propertyCount );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
+ return properties;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayPropertiesKHR,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayPlanePropertiesKHR,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( displayCount <= displays.size() );
- displays.resize( displayCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( displayCount <= displays.size() );
+ displays.resize( displayCount );
+ }
+ return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayKHR,Allocator> displays( vectorAllocator );
+ uint32_t displayCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && displayCount )
+ {
+ displays.resize( displayCount );
+ result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( displayCount <= displays.size() );
+ displays.resize( displayCount );
+ }
return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayModePropertiesKHR,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- template<typename Dispatch>
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection, Dispatch const &d) const
- {
- return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch>
- VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection, Dispatch const &d ) const
- {
- return d.vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection );
- }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
template<typename Dispatch>
VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const
{
result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
- surfaceFormats.resize( surfaceFormatCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
+ }
+ return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SurfaceFormatKHR,Allocator> surfaceFormats( vectorAllocator );
+ uint32_t surfaceFormatCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+ {
+ surfaceFormats.resize( surfaceFormatCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
+ }
return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
- presentModes.resize( presentModeCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+ presentModes.resize( presentModeCount );
+ }
+ return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator );
+ uint32_t presentModeCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && presentModeCount )
+ {
+ presentModes.resize( presentModeCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+ presentModes.resize( presentModeCount );
+ }
return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return features;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return structureChain;
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return features;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return structureChain;
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return properties;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getProperties2(Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return structureChain;
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return properties;
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return structureChain;
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return formatProperties;
}
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+ {
+ StructureChain<X, Y, Z...> structureChain;
+ FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+ d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+ return structureChain;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return formatProperties;
}
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+ {
+ StructureChain<X, Y, Z...> structureChain;
+ FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+ d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+ return structureChain;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
return queueFamilyProperties;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
+ uint32_t queueFamilyPropertyCount;
+ d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ queueFamilyProperties.resize( queueFamilyPropertyCount );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ return queueFamilyProperties;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
return queueFamilyProperties;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
+ uint32_t queueFamilyPropertyCount;
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+ queueFamilyProperties.resize( queueFamilyPropertyCount );
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ return queueFamilyProperties;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
return properties;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+ properties.resize( propertyCount );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+ return properties;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
return properties;
}
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+ properties.resize( propertyCount );
+ d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+ return properties;
+ }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( rectCount <= rects.size() );
- rects.resize( rectCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( rectCount <= rects.size() );
+ rects.resize( rectCount );
+ }
+ return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<Rect2D,Allocator> rects( vectorAllocator );
+ uint32_t rectCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && rectCount )
+ {
+ rects.resize( rectCount );
+ result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( rectCount <= rects.size() );
+ rects.resize( rectCount );
+ }
return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
}
- template <typename ...T, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+ template <typename X, typename Y, typename ...Z, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
{
- StructureChain<T...> structureChain;
+ StructureChain<X, Y, Z...> structureChain;
SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
- surfaceFormats.resize( surfaceFormatCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
+ }
+ return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats( vectorAllocator );
+ uint32_t surfaceFormatCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+ {
+ surfaceFormats.resize( surfaceFormatCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
+ }
return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayProperties2KHR,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayPlaneProperties2KHR,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<DisplayModeProperties2KHR,Allocator> properties( vectorAllocator );
+ uint32_t propertyCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && propertyCount )
+ {
+ properties.resize( propertyCount );
+ result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
+ }
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( pTimeDomains ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Dispatch const &d ) const
+ {
+ std::vector<TimeDomainEXT,Allocator> timeDomains;
+ uint32_t timeDomainCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && timeDomainCount )
+ {
+ timeDomains.resize( timeDomainCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+ timeDomains.resize( timeDomainCount );
+ }
+ return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<TimeDomainEXT,Allocator> timeDomains( vectorAllocator );
+ uint32_t timeDomainCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && timeDomainCount )
+ {
+ timeDomains.resize( timeDomainCount );
+ result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+ timeDomains.resize( timeDomainCount );
+ }
+ return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
struct CmdProcessCommandsInfoNVX
{
CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
return *this;
}
- operator const VkCmdProcessCommandsInfoNVX&() const
+ operator VkCmdProcessCommandsInfoNVX const&() const
{
return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
}
+ operator VkCmdProcessCommandsInfoNVX &()
+ {
+ return *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this);
+ }
+
bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
{
return ( sType == rhs.sType )
struct PhysicalDeviceGroupProperties
{
- operator const VkPhysicalDeviceGroupProperties&() const
+ operator VkPhysicalDeviceGroupProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(this);
}
+ operator VkPhysicalDeviceGroupProperties &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this);
+ }
+
bool operator==( PhysicalDeviceGroupProperties const& rhs ) const
{
return ( sType == rhs.sType )
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- template<typename Dispatch = DispatchLoaderStatic>
- Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderStatic>
- ResultValueType<SurfaceKHR>::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderStatic>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
template<typename Dispatch = DispatchLoaderStatic>
void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ template<typename Dispatch = DispatchLoaderStatic>
+ Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = DispatchLoaderStatic>
+ ResultValueType<SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
template<typename Dispatch = DispatchLoaderStatic>
Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = DispatchLoaderStatic>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const;
+ template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
+ typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_IOS_MVK
result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
- physicalDevices.resize( physicalDeviceCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
+ physicalDevices.resize( physicalDeviceCount );
+ }
+ return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PhysicalDevice,Allocator> physicalDevices( vectorAllocator );
+ uint32_t physicalDeviceCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && physicalDeviceCount )
+ {
+ physicalDevices.resize( physicalDeviceCount );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
+ physicalDevices.resize( physicalDeviceCount );
+ }
return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
- {
- return static_cast<Result>( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
- }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
- {
- SurfaceKHR surface;
- Result result = static_cast<Result>( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
- return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHR" );
- }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
- {
- SurfaceKHR surface;
- Result result = static_cast<Result>( d.vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
- ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
- return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMirSurfaceKHRUnique", deleter );
- }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
template<typename Dispatch>
VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
{
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ SurfaceKHR surface;
+ Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+ return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" );
+ }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ SurfaceKHR surface;
+ Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+
+ ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
+ return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
template<typename Dispatch>
VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const
{
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
- physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ }
+ return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type Instance::enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties( vectorAllocator );
+ uint32_t physicalDeviceGroupCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+ {
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ }
return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
- physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ }
+ return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" );
+ }
+ template <typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type Instance::enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties( vectorAllocator );
+ uint32_t physicalDeviceGroupCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
+ {
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ }
return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
return *this;
}
- operator const VkDeviceGroupDeviceCreateInfo&() const
+ operator VkDeviceGroupDeviceCreateInfo const&() const
{
return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(this);
}
+ operator VkDeviceGroupDeviceCreateInfo &()
+ {
+ return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this);
+ }
+
bool operator==( DeviceGroupDeviceCreateInfo const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBaseOutStructure&() const
+ operator VkBaseOutStructure const&() const
{
return *reinterpret_cast<const VkBaseOutStructure*>(this);
}
+ operator VkBaseOutStructure &()
+ {
+ return *reinterpret_cast<VkBaseOutStructure*>(this);
+ }
+
bool operator==( BaseOutStructure const& rhs ) const
{
return ( sType == rhs.sType )
return *this;
}
- operator const VkBaseInStructure&() const
+ operator VkBaseInStructure const&() const
{
return *reinterpret_cast<const VkBaseInStructure*>(this);
}
+ operator VkBaseInStructure &()
+ {
+ return *reinterpret_cast<VkBaseInStructure*>(this);
+ }
+
bool operator==( BaseInStructure const& rhs ) const
{
return ( sType == rhs.sType )
template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DescriptorPoolCreateInfo, DescriptorPoolInlineUniformBlockCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMaintenance3Properties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDrawParameterFeatures>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDrawParameterFeatures>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceConservativeRasterizationPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCorePropertiesAMD>{ enum { value = true }; };
template <> struct isStructureChainValid<DescriptorSetLayoutSupport, DescriptorSetVariableDescriptorCountLayoutSupportEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineVertexInputStateCreateInfo, PipelineVertexInputDivisorStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceVertexAttributeDivisorPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePCIBusInfoPropertiesEXT>{ enum { value = true }; };
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
template <> struct isStructureChainValid<MemoryAllocateInfo, ImportAndroidHardwareBufferInfoANDROID>{ enum { value = true }; };
#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice8BitStorageFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVulkanMemoryModelFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVulkanMemoryModelFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVertexAttributeDivisorFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVertexAttributeDivisorFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewASTCDecodeModeEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceASTCDecodeFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceASTCDecodeFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTransformFeedbackPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateStreamCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineRepresentativeFragmentTestStateCreateInfoNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportExclusiveScissorStateCreateInfoNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMeshShaderPropertiesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetAccelerationStructureNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRayTracingPropertiesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageDrmFormatModifierInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierListCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfo>{ enum { value = true }; };
+ template <> struct isStructureChainValid<FormatProperties2, DrmFormatModifierPropertiesListEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<BindImageMemoryInfo, BindImagePlaneMemoryInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageMemoryRequirementsInfo2, ImagePlaneMemoryRequirementsInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<InstanceCreateInfo, DebugUtilsMessengerCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DescriptorSetLayoutCreateInfo, DescriptorSetLayoutBindingFlagsCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDriverPropertiesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportShadingRateImageStateCreateInfoNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, DeviceMemoryOverallocationCreateInfoAMD>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfo>{ enum { value = true }; };
VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits)
{
}
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagBitsKHR)
- {
- return "(void)";
- }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
- VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagsKHR)
- {
- return "{}";
- }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
#ifdef VK_USE_PLATFORM_VI_NN
VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN)
{
}
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagBitsFUCHSIA)
+ {
+ return "(void)";
+ }
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagsFUCHSIA)
+ {
+ return "{}";
+ }
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
+
VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBits)
{
return "(void)";
return "{}";
}
+ VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateStreamCreateFlagBitsEXT)
+ {
+ return "(void)";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateStreamCreateFlagsEXT)
+ {
+ return "{}";
+ }
+
VULKAN_HPP_INLINE std::string to_string(ImageLayout value)
{
switch (value)
case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal: return "DepthAttachmentStencilReadOnlyOptimal";
case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR";
case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
+ case ImageLayout::eShadingRateOptimalNV: return "ShadingRateOptimalNV";
default: return "invalid";
}
}
{
case ImageTiling::eOptimal: return "Optimal";
case ImageTiling::eLinear: return "Linear";
+ case ImageTiling::eDrmFormatModifierEXT: return "DrmFormatModifierEXT";
default: return "invalid";
}
}
case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic";
case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic";
case DescriptorType::eInputAttachment: return "InputAttachment";
+ case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT";
+ case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV";
default: return "invalid";
}
}
case QueryType::eOcclusion: return "Occlusion";
case QueryType::ePipelineStatistics: return "PipelineStatistics";
case QueryType::eTimestamp: return "Timestamp";
+ case QueryType::eTransformFeedbackStreamEXT: return "TransformFeedbackStreamEXT";
+ case QueryType::eAccelerationStructureCompactedSizeNV: return "AccelerationStructureCompactedSizeNV";
default: return "invalid";
}
}
{
case PipelineBindPoint::eGraphics: return "Graphics";
case PipelineBindPoint::eCompute: return "Compute";
+ case PipelineBindPoint::eRayTracingNV: return "RayTracingNV";
default: return "invalid";
}
}
{
case IndexType::eUint16: return "Uint16";
case IndexType::eUint32: return "Uint32";
+ case IndexType::eNoneNV: return "NoneNV";
default: return "invalid";
}
}
case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR";
case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR";
case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR";
- case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR";
case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR";
case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR";
case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT";
case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
+ case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT: return "PhysicalDeviceTransformFeedbackFeaturesEXT";
+ case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT: return "PhysicalDeviceTransformFeedbackPropertiesEXT";
+ case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT: return "PipelineRasterizationStateStreamCreateInfoEXT";
case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD";
+ case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV";
case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV";
case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN";
+ case StructureType::eImageViewAstcDecodeModeEXT: return "ImageViewAstcDecodeModeEXT";
+ case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT";
case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR";
case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR";
case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR";
case StructureType::eExternalFormatANDROID: return "ExternalFormatANDROID";
case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT";
case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT";
+ case StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT: return "PhysicalDeviceInlineUniformBlockFeaturesEXT";
+ case StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT: return "PhysicalDeviceInlineUniformBlockPropertiesEXT";
+ case StructureType::eWriteDescriptorSetInlineUniformBlockEXT: return "WriteDescriptorSetInlineUniformBlockEXT";
+ case StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT: return "DescriptorPoolInlineUniformBlockCreateInfoEXT";
case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT";
case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT";
case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT";
case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT";
case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV";
case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV";
+ case StructureType::eDrmFormatModifierPropertiesListEXT: return "DrmFormatModifierPropertiesListEXT";
+ case StructureType::eDrmFormatModifierPropertiesEXT: return "DrmFormatModifierPropertiesEXT";
+ case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT: return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
+ case StructureType::eImageDrmFormatModifierListCreateInfoEXT: return "ImageDrmFormatModifierListCreateInfoEXT";
+ case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT: return "ImageDrmFormatModifierExplicitCreateInfoEXT";
+ case StructureType::eImageDrmFormatModifierPropertiesEXT: return "ImageDrmFormatModifierPropertiesEXT";
case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT";
case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT";
case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT: return "DescriptorSetLayoutBindingFlagsCreateInfoEXT";
case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT: return "PhysicalDeviceDescriptorIndexingPropertiesEXT";
case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT: return "DescriptorSetVariableDescriptorCountAllocateInfoEXT";
case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT: return "DescriptorSetVariableDescriptorCountLayoutSupportEXT";
+ case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV: return "PipelineViewportShadingRateImageStateCreateInfoNV";
+ case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV: return "PhysicalDeviceShadingRateImageFeaturesNV";
+ case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV: return "PhysicalDeviceShadingRateImagePropertiesNV";
+ case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV: return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
+ case StructureType::eRayTracingPipelineCreateInfoNV: return "RayTracingPipelineCreateInfoNV";
+ case StructureType::eAccelerationStructureCreateInfoNV: return "AccelerationStructureCreateInfoNV";
+ case StructureType::eGeometryNV: return "GeometryNV";
+ case StructureType::eGeometryTrianglesNV: return "GeometryTrianglesNV";
+ case StructureType::eGeometryAabbNV: return "GeometryAabbNV";
+ case StructureType::eBindAccelerationStructureMemoryInfoNV: return "BindAccelerationStructureMemoryInfoNV";
+ case StructureType::eWriteDescriptorSetAccelerationStructureNV: return "WriteDescriptorSetAccelerationStructureNV";
+ case StructureType::eAccelerationStructureMemoryRequirementsInfoNV: return "AccelerationStructureMemoryRequirementsInfoNV";
+ case StructureType::ePhysicalDeviceRayTracingPropertiesNV: return "PhysicalDeviceRayTracingPropertiesNV";
+ case StructureType::eRayTracingShaderGroupCreateInfoNV: return "RayTracingShaderGroupCreateInfoNV";
+ case StructureType::eAccelerationStructureInfoNV: return "AccelerationStructureInfoNV";
+ case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV: return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
+ case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT";
case StructureType::ePhysicalDevice8BitStorageFeaturesKHR: return "PhysicalDevice8BitStorageFeaturesKHR";
case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
+ case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR: return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
+ case StructureType::eCalibratedTimestampInfoEXT: return "CalibratedTimestampInfoEXT";
case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD";
+ case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD";
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT";
+ case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
+ case StructureType::ePhysicalDeviceDriverPropertiesKHR: return "PhysicalDeviceDriverPropertiesKHR";
+ case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV: return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
+ case StructureType::ePhysicalDeviceMeshShaderFeaturesNV: return "PhysicalDeviceMeshShaderFeaturesNV";
+ case StructureType::ePhysicalDeviceMeshShaderPropertiesNV: return "PhysicalDeviceMeshShaderPropertiesNV";
+ case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV: return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV";
+ case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV: return "PhysicalDeviceShaderImageFootprintFeaturesNV";
+ case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV: return "PipelineViewportExclusiveScissorStateCreateInfoNV";
+ case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV: return "PhysicalDeviceExclusiveScissorFeaturesNV";
case StructureType::eCheckpointDataNV: return "CheckpointDataNV";
case StructureType::eQueueFamilyCheckpointPropertiesNV: return "QueueFamilyCheckpointPropertiesNV";
+ case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR: return "PhysicalDeviceVulkanMemoryModelFeaturesKHR";
+ case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT: return "PhysicalDevicePciBusInfoPropertiesEXT";
+ case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA";
default: return "invalid";
}
}
case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT";
+ case DynamicState::eViewportShadingRatePaletteNV: return "ViewportShadingRatePaletteNV";
+ case DynamicState::eViewportCoarseSampleOrderNV: return "ViewportCoarseSampleOrderNV";
+ case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
default: return "invalid";
}
}
case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX";
case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT";
case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT";
+ case ObjectType::eAccelerationStructureNV: return "AccelerationStructureNV";
default: return "invalid";
}
}
case AccessFlagBits::eHostWrite: return "HostWrite";
case AccessFlagBits::eMemoryRead: return "MemoryRead";
case AccessFlagBits::eMemoryWrite: return "MemoryWrite";
+ case AccessFlagBits::eTransformFeedbackWriteEXT: return "TransformFeedbackWriteEXT";
+ case AccessFlagBits::eTransformFeedbackCounterReadEXT: return "TransformFeedbackCounterReadEXT";
+ case AccessFlagBits::eTransformFeedbackCounterWriteEXT: return "TransformFeedbackCounterWriteEXT";
case AccessFlagBits::eConditionalRenderingReadEXT: return "ConditionalRenderingReadEXT";
case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX";
case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX";
case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
+ case AccessFlagBits::eShadingRateImageReadNV: return "ShadingRateImageReadNV";
+ case AccessFlagBits::eAccelerationStructureReadNV: return "AccelerationStructureReadNV";
+ case AccessFlagBits::eAccelerationStructureWriteNV: return "AccelerationStructureWriteNV";
default: return "invalid";
}
}
if (value & AccessFlagBits::eHostWrite) result += "HostWrite | ";
if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | ";
if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | ";
+ if (value & AccessFlagBits::eTransformFeedbackWriteEXT) result += "TransformFeedbackWriteEXT | ";
+ if (value & AccessFlagBits::eTransformFeedbackCounterReadEXT) result += "TransformFeedbackCounterReadEXT | ";
+ if (value & AccessFlagBits::eTransformFeedbackCounterWriteEXT) result += "TransformFeedbackCounterWriteEXT | ";
if (value & AccessFlagBits::eConditionalRenderingReadEXT) result += "ConditionalRenderingReadEXT | ";
if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | ";
if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | ";
if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | ";
+ if (value & AccessFlagBits::eShadingRateImageReadNV) result += "ShadingRateImageReadNV | ";
+ if (value & AccessFlagBits::eAccelerationStructureReadNV) result += "AccelerationStructureReadNV | ";
+ if (value & AccessFlagBits::eAccelerationStructureWriteNV) result += "AccelerationStructureWriteNV | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer";
case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer";
case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer";
+ case BufferUsageFlagBits::eTransformFeedbackBufferEXT: return "TransformFeedbackBufferEXT";
+ case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
case BufferUsageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
+ case BufferUsageFlagBits::eRayTracingNV: return "RayTracingNV";
default: return "invalid";
}
}
if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | ";
if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | ";
if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | ";
+ if (value & BufferUsageFlagBits::eTransformFeedbackBufferEXT) result += "TransformFeedbackBufferEXT | ";
+ if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) result += "TransformFeedbackCounterBufferEXT | ";
if (value & BufferUsageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
+ if (value & BufferUsageFlagBits::eRayTracingNV) result += "RayTracingNV | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case ShaderStageFlagBits::eCompute: return "Compute";
case ShaderStageFlagBits::eAllGraphics: return "AllGraphics";
case ShaderStageFlagBits::eAll: return "All";
+ case ShaderStageFlagBits::eRaygenNV: return "RaygenNV";
+ case ShaderStageFlagBits::eAnyHitNV: return "AnyHitNV";
+ case ShaderStageFlagBits::eClosestHitNV: return "ClosestHitNV";
+ case ShaderStageFlagBits::eMissNV: return "MissNV";
+ case ShaderStageFlagBits::eIntersectionNV: return "IntersectionNV";
+ case ShaderStageFlagBits::eCallableNV: return "CallableNV";
+ case ShaderStageFlagBits::eTaskNV: return "TaskNV";
+ case ShaderStageFlagBits::eMeshNV: return "MeshNV";
default: return "invalid";
}
}
if (value & ShaderStageFlagBits::eCompute) result += "Compute | ";
if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | ";
if (value & ShaderStageFlagBits::eAll) result += "All | ";
+ if (value & ShaderStageFlagBits::eRaygenNV) result += "RaygenNV | ";
+ if (value & ShaderStageFlagBits::eAnyHitNV) result += "AnyHitNV | ";
+ if (value & ShaderStageFlagBits::eClosestHitNV) result += "ClosestHitNV | ";
+ if (value & ShaderStageFlagBits::eMissNV) result += "MissNV | ";
+ if (value & ShaderStageFlagBits::eIntersectionNV) result += "IntersectionNV | ";
+ if (value & ShaderStageFlagBits::eCallableNV) result += "CallableNV | ";
+ if (value & ShaderStageFlagBits::eTaskNV) result += "TaskNV | ";
+ if (value & ShaderStageFlagBits::eMeshNV) result += "MeshNV | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment";
case ImageUsageFlagBits::eInputAttachment: return "InputAttachment";
+ case ImageUsageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
default: return "invalid";
}
}
if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | ";
if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | ";
+ if (value & ImageUsageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case ImageCreateFlagBits::eExtendedUsage: return "ExtendedUsage";
case ImageCreateFlagBits::eProtected: return "Protected";
case ImageCreateFlagBits::eDisjoint: return "Disjoint";
+ case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV";
case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
default: return "invalid";
}
if (value & ImageCreateFlagBits::eExtendedUsage) result += "ExtendedUsage | ";
if (value & ImageCreateFlagBits::eProtected) result += "Protected | ";
if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | ";
+ if (value & ImageCreateFlagBits::eCornerSampledNV) result += "CornerSampledNV | ";
if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case PipelineCreateFlagBits::eDerivative: return "Derivative";
case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex";
case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase";
+ case PipelineCreateFlagBits::eDeferCompileNV: return "DeferCompileNV";
default: return "invalid";
}
}
if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | ";
if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex) result += "ViewIndexFromDeviceIndex | ";
if (value & PipelineCreateFlagBits::eDispatchBase) result += "DispatchBase | ";
+ if (value & PipelineCreateFlagBits::eDeferCompileNV) result += "DeferCompileNV | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case ImageAspectFlagBits::ePlane0: return "Plane0";
case ImageAspectFlagBits::ePlane1: return "Plane1";
case ImageAspectFlagBits::ePlane2: return "Plane2";
+ case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT";
+ case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT";
+ case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT";
+ case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT";
default: return "invalid";
}
}
if (value & ImageAspectFlagBits::ePlane0) result += "Plane0 | ";
if (value & ImageAspectFlagBits::ePlane1) result += "Plane1 | ";
if (value & ImageAspectFlagBits::ePlane2) result += "Plane2 | ";
+ if (value & ImageAspectFlagBits::eMemoryPlane0EXT) result += "MemoryPlane0EXT | ";
+ if (value & ImageAspectFlagBits::eMemoryPlane1EXT) result += "MemoryPlane1EXT | ";
+ if (value & ImageAspectFlagBits::eMemoryPlane2EXT) result += "MemoryPlane2EXT | ";
+ if (value & ImageAspectFlagBits::eMemoryPlane3EXT) result += "MemoryPlane3EXT | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
case PipelineStageFlagBits::eHost: return "Host";
case PipelineStageFlagBits::eAllGraphics: return "AllGraphics";
case PipelineStageFlagBits::eAllCommands: return "AllCommands";
+ case PipelineStageFlagBits::eTransformFeedbackEXT: return "TransformFeedbackEXT";
case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX";
+ case PipelineStageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
+ case PipelineStageFlagBits::eRayTracingShaderNV: return "RayTracingShaderNV";
+ case PipelineStageFlagBits::eAccelerationStructureBuildNV: return "AccelerationStructureBuildNV";
+ case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV";
+ case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV";
default: return "invalid";
}
}
if (value & PipelineStageFlagBits::eHost) result += "Host | ";
if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | ";
if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | ";
+ if (value & PipelineStageFlagBits::eTransformFeedbackEXT) result += "TransformFeedbackEXT | ";
if (value & PipelineStageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | ";
+ if (value & PipelineStageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
+ if (value & PipelineStageFlagBits::eRayTracingShaderNV) result += "RayTracingShaderNV | ";
+ if (value & PipelineStageFlagBits::eAccelerationStructureBuildNV) result += "AccelerationStructureBuildNV | ";
+ if (value & PipelineStageFlagBits::eTaskShaderNV) result += "TaskShaderNV | ";
+ if (value & PipelineStageFlagBits::eMeshShaderNV) result += "MeshShaderNV | ";
return "{" + result.substr(0, result.size() - 3) + "}";
}
return "{" + result.substr(0, result.size() - 3) + "}";
}
+ VULKAN_HPP_INLINE std::string to_string(TimeDomainEXT value)
+ {
+ switch (value)
+ {
+ case TimeDomainEXT::eDevice: return "Device";
+ case TimeDomainEXT::eClockMonotonic: return "ClockMonotonic";
+ case TimeDomainEXT::eClockMonotonicRaw: return "ClockMonotonicRaw";
+ case TimeDomainEXT::eQueryPerformanceCounter: return "QueryPerformanceCounter";
+ default: return "invalid";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value)
{
switch (value)
case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt";
case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion";
case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
+ case DebugReportObjectTypeEXT::eAccelerationStructureNV: return "AccelerationStructureNV";
default: return "invalid";
}
}
}
}
+ VULKAN_HPP_INLINE std::string to_string(DriverIdKHR value)
+ {
+ switch (value)
+ {
+ case DriverIdKHR::eAmdProprietary: return "AmdProprietary";
+ case DriverIdKHR::eAmdOpenSource: return "AmdOpenSource";
+ case DriverIdKHR::eMesaRadv: return "MesaRadv";
+ case DriverIdKHR::eNvidiaProprietary: return "NvidiaProprietary";
+ case DriverIdKHR::eIntelProprietaryWindows: return "IntelProprietaryWindows";
+ case DriverIdKHR::eIntelOpenSourceMesa: return "IntelOpenSourceMesa";
+ case DriverIdKHR::eImaginationProprietary: return "ImaginationProprietary";
+ case DriverIdKHR::eQualcommProprietary: return "QualcommProprietary";
+ case DriverIdKHR::eArmProprietary: return "ArmProprietary";
+ default: return "invalid";
+ }
+ }
+
VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagBitsEXT value)
{
switch (value)
return "{" + result.substr(0, result.size() - 3) + "}";
}
+ VULKAN_HPP_INLINE std::string to_string(ShadingRatePaletteEntryNV value)
+ {
+ switch (value)
+ {
+ case ShadingRatePaletteEntryNV::eNoInvocations: return "NoInvocations";
+ case ShadingRatePaletteEntryNV::e16InvocationsPerPixel: return "16InvocationsPerPixel";
+ case ShadingRatePaletteEntryNV::e8InvocationsPerPixel: return "8InvocationsPerPixel";
+ case ShadingRatePaletteEntryNV::e4InvocationsPerPixel: return "4InvocationsPerPixel";
+ case ShadingRatePaletteEntryNV::e2InvocationsPerPixel: return "2InvocationsPerPixel";
+ case ShadingRatePaletteEntryNV::e1InvocationPerPixel: return "1InvocationPerPixel";
+ case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels";
+ case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels";
+ case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels";
+ case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels";
+ case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels";
+ case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(CoarseSampleOrderTypeNV value)
+ {
+ switch (value)
+ {
+ case CoarseSampleOrderTypeNV::eDefault: return "Default";
+ case CoarseSampleOrderTypeNV::eCustom: return "Custom";
+ case CoarseSampleOrderTypeNV::ePixelMajor: return "PixelMajor";
+ case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsNV value)
+ {
+ switch (value)
+ {
+ case GeometryInstanceFlagBitsNV::eTriangleCullDisable: return "TriangleCullDisable";
+ case GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise: return "TriangleFrontCounterclockwise";
+ case GeometryInstanceFlagBitsNV::eForceOpaque: return "ForceOpaque";
+ case GeometryInstanceFlagBitsNV::eForceNoOpaque: return "ForceNoOpaque";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsNV value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & GeometryInstanceFlagBitsNV::eTriangleCullDisable) result += "TriangleCullDisable | ";
+ if (value & GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) result += "TriangleFrontCounterclockwise | ";
+ if (value & GeometryInstanceFlagBitsNV::eForceOpaque) result += "ForceOpaque | ";
+ if (value & GeometryInstanceFlagBitsNV::eForceNoOpaque) result += "ForceNoOpaque | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsNV value)
+ {
+ switch (value)
+ {
+ case GeometryFlagBitsNV::eOpaque: return "Opaque";
+ case GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(GeometryFlagsNV value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & GeometryFlagBitsNV::eOpaque) result += "Opaque | ";
+ if (value & GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation) result += "NoDuplicateAnyHitInvocation | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagBitsNV value)
+ {
+ switch (value)
+ {
+ case BuildAccelerationStructureFlagBitsNV::eAllowUpdate: return "AllowUpdate";
+ case BuildAccelerationStructureFlagBitsNV::eAllowCompaction: return "AllowCompaction";
+ case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace: return "PreferFastTrace";
+ case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild: return "PreferFastBuild";
+ case BuildAccelerationStructureFlagBitsNV::eLowMemory: return "LowMemory";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagsNV value)
+ {
+ if (!value) return "{}";
+ std::string result;
+ if (value & BuildAccelerationStructureFlagBitsNV::eAllowUpdate) result += "AllowUpdate | ";
+ if (value & BuildAccelerationStructureFlagBitsNV::eAllowCompaction) result += "AllowCompaction | ";
+ if (value & BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) result += "PreferFastTrace | ";
+ if (value & BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) result += "PreferFastBuild | ";
+ if (value & BuildAccelerationStructureFlagBitsNV::eLowMemory) result += "LowMemory | ";
+ return "{" + result.substr(0, result.size() - 3) + "}";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(CopyAccelerationStructureModeNV value)
+ {
+ switch (value)
+ {
+ case CopyAccelerationStructureModeNV::eClone: return "Clone";
+ case CopyAccelerationStructureModeNV::eCompact: return "Compact";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeNV value)
+ {
+ switch (value)
+ {
+ case AccelerationStructureTypeNV::eTopLevel: return "TopLevel";
+ case AccelerationStructureTypeNV::eBottomLevel: return "BottomLevel";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(GeometryTypeNV value)
+ {
+ switch (value)
+ {
+ case GeometryTypeNV::eTriangles: return "Triangles";
+ case GeometryTypeNV::eAabbs: return "Aabbs";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(AccelerationStructureMemoryRequirementsTypeNV value)
+ {
+ switch (value)
+ {
+ case AccelerationStructureMemoryRequirementsTypeNV::eObject: return "Object";
+ case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch: return "BuildScratch";
+ case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch: return "UpdateScratch";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(RayTracingShaderGroupTypeNV value)
+ {
+ switch (value)
+ {
+ case RayTracingShaderGroupTypeNV::eGeneral: return "General";
+ case RayTracingShaderGroupTypeNV::eTrianglesHitGroup: return "TrianglesHitGroup";
+ case RayTracingShaderGroupTypeNV::eProceduralHitGroup: return "ProceduralHitGroup";
+ default: return "invalid";
+ }
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(MemoryOverallocationBehaviorAMD value)
+ {
+ switch (value)
+ {
+ case MemoryOverallocationBehaviorAMD::eDefault: return "Default";
+ case MemoryOverallocationBehaviorAMD::eAllowed: return "Allowed";
+ case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed";
+ default: return "invalid";
+ }
+ }
+
class DispatchLoaderDynamic
{
public:
PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
PFN_vkAllocateMemory vkAllocateMemory = 0;
PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
+ PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
PFN_vkBindBufferMemory vkBindBufferMemory = 0;
PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
+ PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0;
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
+ PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0;
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
+ PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
+ PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
PFN_vkCmdBlitImage vkCmdBlitImage = 0;
+ PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0;
PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
+ PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0;
PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
PFN_vkCmdCopyImage vkCmdCopyImage = 0;
PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;
PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;
PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
+ PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0;
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
+ PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
+ PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
+ PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0;
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
PFN_vkCmdEndQuery vkCmdEndQuery = 0;
+ PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0;
PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;
+ PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0;
PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;
PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
PFN_vkCmdResolveImage vkCmdResolveImage = 0;
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
+ PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0;
PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetEvent vkCmdSetEvent = 0;
+ PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
PFN_vkCmdSetScissor vkCmdSetScissor = 0;
PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
PFN_vkCmdSetViewport vkCmdSetViewport = 0;
+ PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;
+ PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0;
PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
+ PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
+ PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
+ PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
#ifdef VK_USE_PLATFORM_ANDROID_KHR
PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
#endif /*VK_USE_PLATFORM_IOS_MVK*/
PFN_vkCreateImage vkCreateImage = 0;
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
PFN_vkCreateImageView vkCreateImageView = 0;
PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX = 0;
PFN_vkCreateInstance vkCreateInstance = 0;
#ifdef VK_USE_PLATFORM_MACOS_MVK
PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR = 0;
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX = 0;
PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
PFN_vkCreateQueryPool vkCreateQueryPool = 0;
+ PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0;
PFN_vkCreateRenderPass vkCreateRenderPass = 0;
PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
PFN_vkCreateSampler vkCreateSampler = 0;
PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
+ PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
PFN_vkDestroyBuffer vkDestroyBuffer = 0;
PFN_vkDestroyBufferView vkDestroyBufferView = 0;
PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
PFN_vkFreeMemory vkFreeMemory = 0;
+ PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
+ PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
+ PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;
PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
#ifdef VK_USE_PLATFORM_WIN32_KHR
PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
+ PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0;
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0;
PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0;
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0;
-#ifdef VK_USE_PLATFORM_MIR_KHR
- PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR = 0;
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
+ PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(device ? device.getProcAddr( "vkAcquireNextImage2KHR") : instance.getProcAddr( "vkAcquireNextImage2KHR"));
vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(device ? device.getProcAddr( "vkAcquireNextImageKHR") : instance.getProcAddr( "vkAcquireNextImageKHR"));
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
- vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(device ? device.getProcAddr( "vkAcquireXlibDisplayEXT") : instance.getProcAddr( "vkAcquireXlibDisplayEXT"));
+ vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(instance.getProcAddr( "vkAcquireXlibDisplayEXT"));
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(device ? device.getProcAddr( "vkAllocateCommandBuffers") : instance.getProcAddr( "vkAllocateCommandBuffers"));
vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets"));
vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory"));
vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(device ? device.getProcAddr( "vkBeginCommandBuffer") : instance.getProcAddr( "vkBeginCommandBuffer"));
+ vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(device ? device.getProcAddr( "vkBindAccelerationStructureMemoryNV") : instance.getProcAddr( "vkBindAccelerationStructureMemoryNV"));
vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory"));
vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2"));
vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR"));
vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(device ? device.getProcAddr( "vkCmdBeginConditionalRenderingEXT") : instance.getProcAddr( "vkCmdBeginConditionalRenderingEXT"));
vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT"));
vkCmdBeginQuery = PFN_vkCmdBeginQuery(device ? device.getProcAddr( "vkCmdBeginQuery") : instance.getProcAddr( "vkCmdBeginQuery"));
+ vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(device ? device.getProcAddr( "vkCmdBeginQueryIndexedEXT") : instance.getProcAddr( "vkCmdBeginQueryIndexedEXT"));
vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(device ? device.getProcAddr( "vkCmdBeginRenderPass") : instance.getProcAddr( "vkCmdBeginRenderPass"));
vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(device ? device.getProcAddr( "vkCmdBeginRenderPass2KHR") : instance.getProcAddr( "vkCmdBeginRenderPass2KHR"));
+ vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(device ? device.getProcAddr( "vkCmdBeginTransformFeedbackEXT") : instance.getProcAddr( "vkCmdBeginTransformFeedbackEXT"));
vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(device ? device.getProcAddr( "vkCmdBindDescriptorSets") : instance.getProcAddr( "vkCmdBindDescriptorSets"));
vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(device ? device.getProcAddr( "vkCmdBindIndexBuffer") : instance.getProcAddr( "vkCmdBindIndexBuffer"));
vkCmdBindPipeline = PFN_vkCmdBindPipeline(device ? device.getProcAddr( "vkCmdBindPipeline") : instance.getProcAddr( "vkCmdBindPipeline"));
+ vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(device ? device.getProcAddr( "vkCmdBindShadingRateImageNV") : instance.getProcAddr( "vkCmdBindShadingRateImageNV"));
+ vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT(device ? device.getProcAddr( "vkCmdBindTransformFeedbackBuffersEXT") : instance.getProcAddr( "vkCmdBindTransformFeedbackBuffersEXT"));
vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(device ? device.getProcAddr( "vkCmdBindVertexBuffers") : instance.getProcAddr( "vkCmdBindVertexBuffers"));
vkCmdBlitImage = PFN_vkCmdBlitImage(device ? device.getProcAddr( "vkCmdBlitImage") : instance.getProcAddr( "vkCmdBlitImage"));
+ vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(device ? device.getProcAddr( "vkCmdBuildAccelerationStructureNV") : instance.getProcAddr( "vkCmdBuildAccelerationStructureNV"));
vkCmdClearAttachments = PFN_vkCmdClearAttachments(device ? device.getProcAddr( "vkCmdClearAttachments") : instance.getProcAddr( "vkCmdClearAttachments"));
vkCmdClearColorImage = PFN_vkCmdClearColorImage(device ? device.getProcAddr( "vkCmdClearColorImage") : instance.getProcAddr( "vkCmdClearColorImage"));
vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(device ? device.getProcAddr( "vkCmdClearDepthStencilImage") : instance.getProcAddr( "vkCmdClearDepthStencilImage"));
+ vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(device ? device.getProcAddr( "vkCmdCopyAccelerationStructureNV") : instance.getProcAddr( "vkCmdCopyAccelerationStructureNV"));
vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(device ? device.getProcAddr( "vkCmdCopyBuffer") : instance.getProcAddr( "vkCmdCopyBuffer"));
vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(device ? device.getProcAddr( "vkCmdCopyBufferToImage") : instance.getProcAddr( "vkCmdCopyBufferToImage"));
vkCmdCopyImage = PFN_vkCmdCopyImage(device ? device.getProcAddr( "vkCmdCopyImage") : instance.getProcAddr( "vkCmdCopyImage"));
vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD"));
vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR"));
vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(device ? device.getProcAddr( "vkCmdDrawIndirect") : instance.getProcAddr( "vkCmdDrawIndirect"));
+ vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(device ? device.getProcAddr( "vkCmdDrawIndirectByteCountEXT") : instance.getProcAddr( "vkCmdDrawIndirectByteCountEXT"));
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndirectCountAMD"));
vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndirectCountKHR"));
+ vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksIndirectCountNV") : instance.getProcAddr( "vkCmdDrawMeshTasksIndirectCountNV"));
+ vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksIndirectNV") : instance.getProcAddr( "vkCmdDrawMeshTasksIndirectNV"));
+ vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksNV") : instance.getProcAddr( "vkCmdDrawMeshTasksNV"));
vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(device ? device.getProcAddr( "vkCmdEndConditionalRenderingEXT") : instance.getProcAddr( "vkCmdEndConditionalRenderingEXT"));
vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdEndDebugUtilsLabelEXT"));
vkCmdEndQuery = PFN_vkCmdEndQuery(device ? device.getProcAddr( "vkCmdEndQuery") : instance.getProcAddr( "vkCmdEndQuery"));
+ vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(device ? device.getProcAddr( "vkCmdEndQueryIndexedEXT") : instance.getProcAddr( "vkCmdEndQueryIndexedEXT"));
vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(device ? device.getProcAddr( "vkCmdEndRenderPass") : instance.getProcAddr( "vkCmdEndRenderPass"));
vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(device ? device.getProcAddr( "vkCmdEndRenderPass2KHR") : instance.getProcAddr( "vkCmdEndRenderPass2KHR"));
+ vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(device ? device.getProcAddr( "vkCmdEndTransformFeedbackEXT") : instance.getProcAddr( "vkCmdEndTransformFeedbackEXT"));
vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(device ? device.getProcAddr( "vkCmdExecuteCommands") : instance.getProcAddr( "vkCmdExecuteCommands"));
vkCmdFillBuffer = PFN_vkCmdFillBuffer(device ? device.getProcAddr( "vkCmdFillBuffer") : instance.getProcAddr( "vkCmdFillBuffer"));
vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT"));
vkCmdResolveImage = PFN_vkCmdResolveImage(device ? device.getProcAddr( "vkCmdResolveImage") : instance.getProcAddr( "vkCmdResolveImage"));
vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(device ? device.getProcAddr( "vkCmdSetBlendConstants") : instance.getProcAddr( "vkCmdSetBlendConstants"));
vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(device ? device.getProcAddr( "vkCmdSetCheckpointNV") : instance.getProcAddr( "vkCmdSetCheckpointNV"));
+ vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(device ? device.getProcAddr( "vkCmdSetCoarseSampleOrderNV") : instance.getProcAddr( "vkCmdSetCoarseSampleOrderNV"));
vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(device ? device.getProcAddr( "vkCmdSetDepthBias") : instance.getProcAddr( "vkCmdSetDepthBias"));
vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(device ? device.getProcAddr( "vkCmdSetDepthBounds") : instance.getProcAddr( "vkCmdSetDepthBounds"));
vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(device ? device.getProcAddr( "vkCmdSetDeviceMask") : instance.getProcAddr( "vkCmdSetDeviceMask"));
vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(device ? device.getProcAddr( "vkCmdSetDeviceMaskKHR") : instance.getProcAddr( "vkCmdSetDeviceMaskKHR"));
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(device ? device.getProcAddr( "vkCmdSetDiscardRectangleEXT") : instance.getProcAddr( "vkCmdSetDiscardRectangleEXT"));
vkCmdSetEvent = PFN_vkCmdSetEvent(device ? device.getProcAddr( "vkCmdSetEvent") : instance.getProcAddr( "vkCmdSetEvent"));
+ vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(device ? device.getProcAddr( "vkCmdSetExclusiveScissorNV") : instance.getProcAddr( "vkCmdSetExclusiveScissorNV"));
vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(device ? device.getProcAddr( "vkCmdSetLineWidth") : instance.getProcAddr( "vkCmdSetLineWidth"));
vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(device ? device.getProcAddr( "vkCmdSetSampleLocationsEXT") : instance.getProcAddr( "vkCmdSetSampleLocationsEXT"));
vkCmdSetScissor = PFN_vkCmdSetScissor(device ? device.getProcAddr( "vkCmdSetScissor") : instance.getProcAddr( "vkCmdSetScissor"));
vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(device ? device.getProcAddr( "vkCmdSetStencilReference") : instance.getProcAddr( "vkCmdSetStencilReference"));
vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(device ? device.getProcAddr( "vkCmdSetStencilWriteMask") : instance.getProcAddr( "vkCmdSetStencilWriteMask"));
vkCmdSetViewport = PFN_vkCmdSetViewport(device ? device.getProcAddr( "vkCmdSetViewport") : instance.getProcAddr( "vkCmdSetViewport"));
+ vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV(device ? device.getProcAddr( "vkCmdSetViewportShadingRatePaletteNV") : instance.getProcAddr( "vkCmdSetViewportShadingRatePaletteNV"));
vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(device ? device.getProcAddr( "vkCmdSetViewportWScalingNV") : instance.getProcAddr( "vkCmdSetViewportWScalingNV"));
+ vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(device ? device.getProcAddr( "vkCmdTraceRaysNV") : instance.getProcAddr( "vkCmdTraceRaysNV"));
vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(device ? device.getProcAddr( "vkCmdUpdateBuffer") : instance.getProcAddr( "vkCmdUpdateBuffer"));
vkCmdWaitEvents = PFN_vkCmdWaitEvents(device ? device.getProcAddr( "vkCmdWaitEvents") : instance.getProcAddr( "vkCmdWaitEvents"));
+ vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(device ? device.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV") : instance.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV"));
vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(device ? device.getProcAddr( "vkCmdWriteBufferMarkerAMD") : instance.getProcAddr( "vkCmdWriteBufferMarkerAMD"));
vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(device ? device.getProcAddr( "vkCmdWriteTimestamp") : instance.getProcAddr( "vkCmdWriteTimestamp"));
+ vkCompileDeferredNV = PFN_vkCompileDeferredNV(device ? device.getProcAddr( "vkCompileDeferredNV") : instance.getProcAddr( "vkCompileDeferredNV"));
+ vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(device ? device.getProcAddr( "vkCreateAccelerationStructureNV") : instance.getProcAddr( "vkCreateAccelerationStructureNV"));
#ifdef VK_USE_PLATFORM_ANDROID_KHR
vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR"));
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(device ? device.getProcAddr( "vkCreateDescriptorSetLayout") : instance.getProcAddr( "vkCreateDescriptorSetLayout"));
vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplate") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplate"));
vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR"));
- vkCreateDevice = PFN_vkCreateDevice(device ? device.getProcAddr( "vkCreateDevice") : instance.getProcAddr( "vkCreateDevice"));
- vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(device ? device.getProcAddr( "vkCreateDisplayModeKHR") : instance.getProcAddr( "vkCreateDisplayModeKHR"));
+ vkCreateDevice = PFN_vkCreateDevice(instance.getProcAddr( "vkCreateDevice"));
+ vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(instance.getProcAddr( "vkCreateDisplayModeKHR"));
vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(instance.getProcAddr( "vkCreateDisplayPlaneSurfaceKHR"));
vkCreateEvent = PFN_vkCreateEvent(device ? device.getProcAddr( "vkCreateEvent") : instance.getProcAddr( "vkCreateEvent"));
vkCreateFence = PFN_vkCreateFence(device ? device.getProcAddr( "vkCreateFence") : instance.getProcAddr( "vkCreateFence"));
vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(instance.getProcAddr( "vkCreateIOSSurfaceMVK"));
#endif /*VK_USE_PLATFORM_IOS_MVK*/
vkCreateImage = PFN_vkCreateImage(device ? device.getProcAddr( "vkCreateImage") : instance.getProcAddr( "vkCreateImage"));
+#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
+ vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(instance.getProcAddr( "vkCreateImagePipeSurfaceFUCHSIA"));
+#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
vkCreateImageView = PFN_vkCreateImageView(device ? device.getProcAddr( "vkCreateImageView") : instance.getProcAddr( "vkCreateImageView"));
vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkCreateIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkCreateIndirectCommandsLayoutNVX"));
vkCreateInstance = PFN_vkCreateInstance(instance.getProcAddr( "vkCreateInstance"));
#ifdef VK_USE_PLATFORM_MACOS_MVK
vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK"));
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-#ifdef VK_USE_PLATFORM_MIR_KHR
- vkCreateMirSurfaceKHR = PFN_vkCreateMirSurfaceKHR(instance.getProcAddr( "vkCreateMirSurfaceKHR"));
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX(device ? device.getProcAddr( "vkCreateObjectTableNVX") : instance.getProcAddr( "vkCreateObjectTableNVX"));
vkCreatePipelineCache = PFN_vkCreatePipelineCache(device ? device.getProcAddr( "vkCreatePipelineCache") : instance.getProcAddr( "vkCreatePipelineCache"));
vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(device ? device.getProcAddr( "vkCreatePipelineLayout") : instance.getProcAddr( "vkCreatePipelineLayout"));
vkCreateQueryPool = PFN_vkCreateQueryPool(device ? device.getProcAddr( "vkCreateQueryPool") : instance.getProcAddr( "vkCreateQueryPool"));
+ vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(device ? device.getProcAddr( "vkCreateRayTracingPipelinesNV") : instance.getProcAddr( "vkCreateRayTracingPipelinesNV"));
vkCreateRenderPass = PFN_vkCreateRenderPass(device ? device.getProcAddr( "vkCreateRenderPass") : instance.getProcAddr( "vkCreateRenderPass"));
vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(device ? device.getProcAddr( "vkCreateRenderPass2KHR") : instance.getProcAddr( "vkCreateRenderPass2KHR"));
vkCreateSampler = PFN_vkCreateSampler(device ? device.getProcAddr( "vkCreateSampler") : instance.getProcAddr( "vkCreateSampler"));
vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectNameEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectNameEXT"));
vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectTagEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectTagEXT"));
vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT"));
+ vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(device ? device.getProcAddr( "vkDestroyAccelerationStructureNV") : instance.getProcAddr( "vkDestroyAccelerationStructureNV"));
vkDestroyBuffer = PFN_vkDestroyBuffer(device ? device.getProcAddr( "vkDestroyBuffer") : instance.getProcAddr( "vkDestroyBuffer"));
vkDestroyBufferView = PFN_vkDestroyBufferView(device ? device.getProcAddr( "vkDestroyBufferView") : instance.getProcAddr( "vkDestroyBufferView"));
vkDestroyCommandPool = PFN_vkDestroyCommandPool(device ? device.getProcAddr( "vkDestroyCommandPool") : instance.getProcAddr( "vkDestroyCommandPool"));
vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(device ? device.getProcAddr( "vkDeviceWaitIdle") : instance.getProcAddr( "vkDeviceWaitIdle"));
vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(device ? device.getProcAddr( "vkDisplayPowerControlEXT") : instance.getProcAddr( "vkDisplayPowerControlEXT"));
vkEndCommandBuffer = PFN_vkEndCommandBuffer(device ? device.getProcAddr( "vkEndCommandBuffer") : instance.getProcAddr( "vkEndCommandBuffer"));
- vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(device ? device.getProcAddr( "vkEnumerateDeviceExtensionProperties") : instance.getProcAddr( "vkEnumerateDeviceExtensionProperties"));
- vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(device ? device.getProcAddr( "vkEnumerateDeviceLayerProperties") : instance.getProcAddr( "vkEnumerateDeviceLayerProperties"));
+ vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(instance.getProcAddr( "vkEnumerateDeviceExtensionProperties"));
+ vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(instance.getProcAddr( "vkEnumerateDeviceLayerProperties"));
vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties(instance.getProcAddr( "vkEnumerateInstanceExtensionProperties"));
vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(instance.getProcAddr( "vkEnumerateInstanceLayerProperties"));
vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(instance.getProcAddr( "vkEnumerateInstanceVersion"));
vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(device ? device.getProcAddr( "vkFreeCommandBuffers") : instance.getProcAddr( "vkFreeCommandBuffers"));
vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(device ? device.getProcAddr( "vkFreeDescriptorSets") : instance.getProcAddr( "vkFreeDescriptorSets"));
vkFreeMemory = PFN_vkFreeMemory(device ? device.getProcAddr( "vkFreeMemory") : instance.getProcAddr( "vkFreeMemory"));
+ vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(device ? device.getProcAddr( "vkGetAccelerationStructureHandleNV") : instance.getProcAddr( "vkGetAccelerationStructureHandleNV"));
+ vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV(device ? device.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNV") : instance.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNV"));
#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID"));
#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(device ? device.getProcAddr( "vkGetBufferMemoryRequirements") : instance.getProcAddr( "vkGetBufferMemoryRequirements"));
vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2") : instance.getProcAddr( "vkGetBufferMemoryRequirements2"));
vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2KHR") : instance.getProcAddr( "vkGetBufferMemoryRequirements2KHR"));
+ vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(device ? device.getProcAddr( "vkGetCalibratedTimestampsEXT") : instance.getProcAddr( "vkGetCalibratedTimestampsEXT"));
vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupport") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupport"));
vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR"));
vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures"));
vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(device ? device.getProcAddr( "vkGetDeviceProcAddr") : instance.getProcAddr( "vkGetDeviceProcAddr"));
vkGetDeviceQueue = PFN_vkGetDeviceQueue(device ? device.getProcAddr( "vkGetDeviceQueue") : instance.getProcAddr( "vkGetDeviceQueue"));
vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(device ? device.getProcAddr( "vkGetDeviceQueue2") : instance.getProcAddr( "vkGetDeviceQueue2"));
- vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(device ? device.getProcAddr( "vkGetDisplayModeProperties2KHR") : instance.getProcAddr( "vkGetDisplayModeProperties2KHR"));
- vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(device ? device.getProcAddr( "vkGetDisplayModePropertiesKHR") : instance.getProcAddr( "vkGetDisplayModePropertiesKHR"));
- vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(device ? device.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR") : instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR"));
- vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(device ? device.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR") : instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR"));
- vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(device ? device.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR") : instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR"));
+ vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(instance.getProcAddr( "vkGetDisplayModeProperties2KHR"));
+ vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(instance.getProcAddr( "vkGetDisplayModePropertiesKHR"));
+ vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR"));
+ vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR"));
+ vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR"));
vkGetEventStatus = PFN_vkGetEventStatus(device ? device.getProcAddr( "vkGetEventStatus") : instance.getProcAddr( "vkGetEventStatus"));
vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(device ? device.getProcAddr( "vkGetFenceFdKHR") : instance.getProcAddr( "vkGetFenceFdKHR"));
vkGetFenceStatus = PFN_vkGetFenceStatus(device ? device.getProcAddr( "vkGetFenceStatus") : instance.getProcAddr( "vkGetFenceStatus"));
#ifdef VK_USE_PLATFORM_WIN32_KHR
vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(device ? device.getProcAddr( "vkGetFenceWin32HandleKHR") : instance.getProcAddr( "vkGetFenceWin32HandleKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT(device ? device.getProcAddr( "vkGetImageDrmFormatModifierPropertiesEXT") : instance.getProcAddr( "vkGetImageDrmFormatModifierPropertiesEXT"));
vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(device ? device.getProcAddr( "vkGetImageMemoryRequirements") : instance.getProcAddr( "vkGetImageMemoryRequirements"));
vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(device ? device.getProcAddr( "vkGetImageMemoryRequirements2") : instance.getProcAddr( "vkGetImageMemoryRequirements2"));
vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageMemoryRequirements2KHR"));
vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR") : instance.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(device ? device.getProcAddr( "vkGetPastPresentationTimingGOOGLE") : instance.getProcAddr( "vkGetPastPresentationTimingGOOGLE"));
- vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"));
- vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
- vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR"));
- vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR"));
- vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties"));
- vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR"));
- vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties"));
- vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
- vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV") : instance.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"));
- vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties") : instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties"));
- vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"));
- vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures"));
- vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures2") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures2"));
- vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR"));
- vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties"));
- vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2"));
- vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR"));
- vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(device ? device.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX") : instance.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"));
- vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties"));
- vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2"));
- vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR"));
- vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties"));
- vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2"));
- vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR"));
-#ifdef VK_USE_PLATFORM_MIR_KHR
- vkGetPhysicalDeviceMirPresentationSupportKHR = PFN_vkGetPhysicalDeviceMirPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceMirPresentationSupportKHR"));
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
- vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(device ? device.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT") : instance.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
- vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(device ? device.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR") : instance.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR"));
- vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties") : instance.getProcAddr( "vkGetPhysicalDeviceProperties"));
- vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceProperties2"));
- vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceProperties2KHR"));
- vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties"));
- vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2"));
- vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR"));
- vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties"));
- vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2"));
- vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"));
- vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
- vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR"));
- vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
- vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR"));
- vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR"));
- vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR"));
- vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR"));
+ vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(instance.getProcAddr( "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"));
+ vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"));
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
+ vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR"));
+ vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR"));
+ vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties"));
+ vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR"));
+ vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(instance.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties"));
+ vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
+ vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(instance.getProcAddr( "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"));
+ vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties"));
+ vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"));
+ vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(instance.getProcAddr( "vkGetPhysicalDeviceFeatures"));
+ vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(instance.getProcAddr( "vkGetPhysicalDeviceFeatures2"));
+ vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(instance.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR"));
+ vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties"));
+ vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2"));
+ vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR"));
+ vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(instance.getProcAddr( "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"));
+ vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties(instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties"));
+ vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2"));
+ vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR"));
+ vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties"));
+ vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2"));
+ vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR"));
+ vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(instance.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
+ vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(instance.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR"));
+ vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(instance.getProcAddr( "vkGetPhysicalDeviceProperties"));
+ vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(instance.getProcAddr( "vkGetPhysicalDeviceProperties2"));
+ vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceProperties2KHR"));
+ vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties(instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties"));
+ vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2"));
+ vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR"));
+ vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties(instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties"));
+ vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2"));
+ vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"));
+ vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+ vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR"));
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
+ vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR"));
+ vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR"));
+ vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR"));
+ vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR"));
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
- vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
+ vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
+ vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_XCB_KHR
- vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
+ vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#ifdef VK_USE_PLATFORM_XLIB_KHR
- vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(device ? device.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR") : instance.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
+ vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(device ? device.getProcAddr( "vkGetPipelineCacheData") : instance.getProcAddr( "vkGetPipelineCacheData"));
vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(device ? device.getProcAddr( "vkGetQueryPoolResults") : instance.getProcAddr( "vkGetQueryPoolResults"));
vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(device ? device.getProcAddr( "vkGetQueueCheckpointDataNV") : instance.getProcAddr( "vkGetQueueCheckpointDataNV"));
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
- vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(device ? device.getProcAddr( "vkGetRandROutputDisplayEXT") : instance.getProcAddr( "vkGetRandROutputDisplayEXT"));
+ vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(instance.getProcAddr( "vkGetRandROutputDisplayEXT"));
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
+ vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(device ? device.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV") : instance.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV"));
vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE"));
vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity"));
vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR"));
vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(device ? device.getProcAddr( "vkRegisterDeviceEventEXT") : instance.getProcAddr( "vkRegisterDeviceEventEXT"));
vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(device ? device.getProcAddr( "vkRegisterDisplayEventEXT") : instance.getProcAddr( "vkRegisterDisplayEventEXT"));
vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX(device ? device.getProcAddr( "vkRegisterObjectsNVX") : instance.getProcAddr( "vkRegisterObjectsNVX"));
- vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(device ? device.getProcAddr( "vkReleaseDisplayEXT") : instance.getProcAddr( "vkReleaseDisplayEXT"));
+ vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(instance.getProcAddr( "vkReleaseDisplayEXT"));
vkResetCommandBuffer = PFN_vkResetCommandBuffer(device ? device.getProcAddr( "vkResetCommandBuffer") : instance.getProcAddr( "vkResetCommandBuffer"));
vkResetCommandPool = PFN_vkResetCommandPool(device ? device.getProcAddr( "vkResetCommandPool") : instance.getProcAddr( "vkResetCommandPool"));
vkResetDescriptorPool = PFN_vkResetDescriptorPool(device ? device.getProcAddr( "vkResetDescriptorPool") : instance.getProcAddr( "vkResetDescriptorPool"));
OSDN Git Service
