Vulkan API

PFN_vkAllocationFunction
PFN_vkDebugReportCallbackEXT
PFN_vkDebugUtilsMessengerCallbackEXT
PFN_vkDeviceMemoryReportCallbackEXT
PFN_vkFreeFunction
PFN_vkInternalAllocationNotification
PFN_vkInternalFreeNotification
PFN_vkReallocationFunction
PFN_vkVoidFunction
VkAabbPositionsKHR
VkAabbPositionsNV
VkAccelerationStructureBuildGeometryInfoKHR
VkAccelerationStructureBuildRangeInfoKHR
VkAccelerationStructureBuildSizesInfoKHR
VkAccelerationStructureBuildTypeKHR
VkAccelerationStructureCompatibilityKHR
VkAccelerationStructureCreateFlagBitsKHR
VkAccelerationStructureCreateFlagsKHR
VkAccelerationStructureCreateInfoKHR
VkAccelerationStructureCreateInfoNV
VkAccelerationStructureDeviceAddressInfoKHR
VkAccelerationStructureGeometryAabbsDataKHR
VkAccelerationStructureGeometryDataKHR
VkAccelerationStructureGeometryInstancesDataKHR
VkAccelerationStructureGeometryKHR
VkAccelerationStructureGeometryMotionTrianglesDataNV
VkAccelerationStructureGeometryTrianglesDataKHR
VkAccelerationStructureInfoNV
VkAccelerationStructureInstanceKHR
VkAccelerationStructureInstanceNV
VkAccelerationStructureKHR
VkAccelerationStructureMatrixMotionInstanceNV
VkAccelerationStructureMemoryRequirementsInfoNV
VkAccelerationStructureMemoryRequirementsTypeNV
VkAccelerationStructureMotionInfoFlagsNV
VkAccelerationStructureMotionInfoNV
VkAccelerationStructureMotionInstanceDataNV
VkAccelerationStructureMotionInstanceFlagsNV
VkAccelerationStructureMotionInstanceNV
VkAccelerationStructureMotionInstanceTypeNV
VkAccelerationStructureNV
VkAccelerationStructureSRTMotionInstanceNV
VkAccelerationStructureTypeKHR
VkAccelerationStructureTypeNV
VkAccelerationStructureVersionInfoKHR
vkAcquireDrmDisplayEXT
vkAcquireFullScreenExclusiveModeEXT
vkAcquireNextImage2KHR
VkAcquireNextImageInfoKHR
vkAcquireNextImageKHR
vkAcquirePerformanceConfigurationINTEL
VkAcquireProfilingLockFlagBitsKHR
VkAcquireProfilingLockFlagsKHR
VkAcquireProfilingLockInfoKHR
vkAcquireProfilingLockKHR
vkAcquireWinrtDisplayNV
vkAcquireXlibDisplayEXT
vkAllocateCommandBuffers
vkAllocateDescriptorSets
vkAllocateMemory
VkAndroidHardwareBufferFormatProperties2ANDROID
VkAndroidHardwareBufferFormatPropertiesANDROID
VkAndroidHardwareBufferPropertiesANDROID
VkAndroidHardwareBufferUsageANDROID
VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateInfoKHR
VKAPI_ATTR
VKAPI_CALL
VKAPI_PTR
VkApplicationInfo
VkAttachmentDescription2
VkAttachmentDescription2KHR
VkAttachmentDescriptionFlagBits
VkAttachmentDescriptionFlags
VkAttachmentDescriptionStencilLayout
VkAttachmentDescriptionStencilLayoutKHR
VkAttachmentLoadOp
VkAttachmentReference
VkAttachmentReference2
VkAttachmentReference2KHR
VkAttachmentReferenceStencilLayout
VkAttachmentReferenceStencilLayoutKHR
VkAttachmentSampleCountInfoAMD
VkAttachmentSampleCountInfoNV
VkAttachmentSampleLocationsEXT
VkAttachmentStoreOp
VkBaseInStructure
VkBaseOutStructure
vkBeginCommandBuffer
VkBindAccelerationStructureMemoryInfoNV
vkBindAccelerationStructureMemoryNV
vkBindBufferMemory
vkBindBufferMemory2
vkBindBufferMemory2KHR
VkBindBufferMemoryDeviceGroupInfo
VkBindBufferMemoryDeviceGroupInfoKHR
VkBindBufferMemoryInfo
VkBindBufferMemoryInfoKHR
vkBindImageMemory
vkBindImageMemory2
vkBindImageMemory2KHR
VkBindImageMemoryDeviceGroupInfo
VkBindImageMemoryDeviceGroupInfoKHR
VkBindImageMemoryInfo
VkBindImageMemoryInfoKHR
VkBindImageMemorySwapchainInfoKHR
VkBindImagePlaneMemoryInfo
VkBindImagePlaneMemoryInfoKHR
VkBindIndexBufferIndirectCommandNV
VkBindShaderGroupIndirectCommandNV
VkBindSparseInfo
VkBindVertexBufferIndirectCommandNV
vkBindVideoSessionMemoryKHR
VkBlendFactor
VkBlendOp
VkBlendOverlapEXT
VkBlitImageInfo2
VkBlitImageInfo2KHR
VkBool32
VkBorderColor
VkBuffer
VkBufferCollectionBufferCreateInfoFUCHSIA
VkBufferCollectionConstraintsInfoFUCHSIA
VkBufferCollectionCreateInfoFUCHSIA
VkBufferCollectionFUCHSIA
VkBufferCollectionImageCreateInfoFUCHSIA
VkBufferCollectionPropertiesFUCHSIA
VkBufferConstraintsInfoFUCHSIA
VkBufferCopy
VkBufferCopy2
VkBufferCopy2KHR
VkBufferCreateFlagBits
VkBufferCreateFlags
VkBufferDeviceAddressCreateInfoEXT
VkBufferDeviceAddressInfo
VkBufferDeviceAddressInfoEXT
VkBufferDeviceAddressInfoKHR
VkBufferImageCopy
VkBufferImageCopy2
VkBufferImageCopy2KHR
VkBufferMemoryBarrier
VkBufferMemoryBarrier2
VkBufferMemoryBarrier2KHR
VkBufferMemoryRequirementsInfo2
VkBufferMemoryRequirementsInfo2KHR
VkBufferOpaqueCaptureAddressCreateInfo
VkBufferOpaqueCaptureAddressCreateInfoKHR
VkBufferUsageFlagBits
VkBufferUsageFlags
VkBufferView
VkBufferViewCreateFlags
VkBufferViewCreateInfo
VkBuildAccelerationStructureFlagBitsKHR
VkBuildAccelerationStructureFlagBitsNV
VkBuildAccelerationStructureFlagsKHR
VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureModeKHR
vkBuildAccelerationStructuresKHR
VkCalibratedTimestampInfoEXT
VkCheckpointData2NV
VkCheckpointDataNV
VkChromaLocation
VkChromaLocationKHR
VkClearAttachment
VkClearColorValue
VkClearDepthStencilValue
VkClearRect
vkCmdBeginConditionalRenderingEXT
vkCmdBeginDebugUtilsLabelEXT
vkCmdBeginQuery
vkCmdBeginQueryIndexedEXT
vkCmdBeginRendering
vkCmdBeginRenderingKHR
vkCmdBeginRenderPass
vkCmdBeginRenderPass2
vkCmdBeginRenderPass2KHR
vkCmdBeginTransformFeedbackEXT
vkCmdBeginVideoCodingKHR
vkCmdBindDescriptorSets
vkCmdBindIndexBuffer
vkCmdBindInvocationMaskHUAWEI
vkCmdBindPipeline
vkCmdBindPipelineShaderGroupNV
vkCmdBindShadingRateImageNV
vkCmdBindTransformFeedbackBuffersEXT
vkCmdBindVertexBuffers
vkCmdBindVertexBuffers2
vkCmdBindVertexBuffers2EXT
vkCmdBlitImage
vkCmdBlitImage2
vkCmdBlitImage2KHR
vkCmdBuildAccelerationStructureNV
vkCmdBuildAccelerationStructuresIndirectKHR
vkCmdBuildAccelerationStructuresKHR
vkCmdClearAttachments
vkCmdClearColorImage
vkCmdClearDepthStencilImage
vkCmdControlVideoCodingKHR
vkCmdCopyAccelerationStructureKHR
vkCmdCopyAccelerationStructureNV
vkCmdCopyAccelerationStructureToMemoryKHR
vkCmdCopyBuffer
vkCmdCopyBuffer2
vkCmdCopyBuffer2KHR
vkCmdCopyBufferToImage
vkCmdCopyBufferToImage2
vkCmdCopyBufferToImage2KHR
vkCmdCopyImage
vkCmdCopyImage2
vkCmdCopyImage2KHR
vkCmdCopyImageToBuffer
vkCmdCopyImageToBuffer2
vkCmdCopyImageToBuffer2KHR
vkCmdCopyMemoryToAccelerationStructureKHR
vkCmdCopyQueryPoolResults
vkCmdCuLaunchKernelNVX
vkCmdDebugMarkerBeginEXT
vkCmdDebugMarkerEndEXT
vkCmdDebugMarkerInsertEXT
vkCmdDecodeVideoKHR
vkCmdDispatch
vkCmdDispatchBase
vkCmdDispatchBaseKHR
vkCmdDispatchIndirect
vkCmdDraw
vkCmdDrawIndexed
vkCmdDrawIndexedIndirect
vkCmdDrawIndexedIndirectCount
vkCmdDrawIndexedIndirectCountAMD
vkCmdDrawIndexedIndirectCountKHR
vkCmdDrawIndirect
vkCmdDrawIndirectByteCountEXT
vkCmdDrawIndirectCount
vkCmdDrawIndirectCountAMD
vkCmdDrawIndirectCountKHR
vkCmdDrawMeshTasksIndirectCountNV
vkCmdDrawMeshTasksIndirectNV
vkCmdDrawMeshTasksNV
vkCmdDrawMultiEXT
vkCmdDrawMultiIndexedEXT
vkCmdEncodeVideoKHR
vkCmdEndConditionalRenderingEXT
vkCmdEndDebugUtilsLabelEXT
vkCmdEndQuery
vkCmdEndQueryIndexedEXT
vkCmdEndRendering
vkCmdEndRenderingKHR
vkCmdEndRenderPass
vkCmdEndRenderPass2
vkCmdEndRenderPass2KHR
vkCmdEndTransformFeedbackEXT
vkCmdEndVideoCodingKHR
vkCmdExecuteCommands
vkCmdExecuteGeneratedCommandsNV
vkCmdFillBuffer
vkCmdInsertDebugUtilsLabelEXT
vkCmdNextSubpass
vkCmdNextSubpass2
vkCmdNextSubpass2KHR
vkCmdPipelineBarrier
vkCmdPipelineBarrier2
vkCmdPipelineBarrier2KHR
vkCmdPreprocessGeneratedCommandsNV
vkCmdPushConstants
vkCmdPushDescriptorSetKHR
vkCmdPushDescriptorSetWithTemplateKHR
vkCmdResetEvent
vkCmdResetEvent2
vkCmdResetEvent2KHR
vkCmdResetQueryPool
vkCmdResolveImage
vkCmdResolveImage2
vkCmdResolveImage2KHR
vkCmdSetBlendConstants
vkCmdSetCheckpointNV
vkCmdSetCoarseSampleOrderNV
vkCmdSetColorWriteEnableEXT
vkCmdSetCullMode
vkCmdSetCullModeEXT
vkCmdSetDepthBias
vkCmdSetDepthBiasEnable
vkCmdSetDepthBiasEnableEXT
vkCmdSetDepthBounds
vkCmdSetDepthBoundsTestEnable
vkCmdSetDepthBoundsTestEnableEXT
vkCmdSetDepthCompareOp
vkCmdSetDepthCompareOpEXT
vkCmdSetDepthTestEnable
vkCmdSetDepthTestEnableEXT
vkCmdSetDepthWriteEnable
vkCmdSetDepthWriteEnableEXT
vkCmdSetDeviceMask
vkCmdSetDeviceMaskKHR
vkCmdSetDiscardRectangleEXT
vkCmdSetEvent
vkCmdSetEvent2
vkCmdSetEvent2KHR
vkCmdSetExclusiveScissorNV
vkCmdSetFragmentShadingRateEnumNV
vkCmdSetFragmentShadingRateKHR
vkCmdSetFrontFace
vkCmdSetFrontFaceEXT
vkCmdSetLineStippleEXT
vkCmdSetLineWidth
vkCmdSetLogicOpEXT
vkCmdSetPatchControlPointsEXT
vkCmdSetPerformanceMarkerINTEL
vkCmdSetPerformanceOverrideINTEL
vkCmdSetPerformanceStreamMarkerINTEL
vkCmdSetPrimitiveRestartEnable
vkCmdSetPrimitiveRestartEnableEXT
vkCmdSetPrimitiveTopology
vkCmdSetPrimitiveTopologyEXT
vkCmdSetRasterizerDiscardEnable
vkCmdSetRasterizerDiscardEnableEXT
vkCmdSetRayTracingPipelineStackSizeKHR
vkCmdSetSampleLocationsEXT
vkCmdSetScissor
vkCmdSetScissorWithCount
vkCmdSetScissorWithCountEXT
vkCmdSetStencilCompareMask
vkCmdSetStencilOp
vkCmdSetStencilOpEXT
vkCmdSetStencilReference
vkCmdSetStencilTestEnable
vkCmdSetStencilTestEnableEXT
vkCmdSetStencilWriteMask
vkCmdSetVertexInputEXT
vkCmdSetViewport
vkCmdSetViewportShadingRatePaletteNV
vkCmdSetViewportWithCount
vkCmdSetViewportWithCountEXT
vkCmdSetViewportWScalingNV
vkCmdSubpassShadingHUAWEI
vkCmdTraceRaysIndirectKHR
vkCmdTraceRaysKHR
vkCmdTraceRaysNV
vkCmdUpdateBuffer
vkCmdWaitEvents
vkCmdWaitEvents2
vkCmdWaitEvents2KHR
vkCmdWriteAccelerationStructuresPropertiesKHR
vkCmdWriteAccelerationStructuresPropertiesNV
vkCmdWriteBufferMarker2AMD
vkCmdWriteBufferMarkerAMD
vkCmdWriteTimestamp
vkCmdWriteTimestamp2
vkCmdWriteTimestamp2KHR
VkCoarseSampleLocationNV
VkCoarseSampleOrderCustomNV
VkCoarseSampleOrderTypeNV
VkColorComponentFlagBits
VkColorComponentFlags
VkColorSpaceKHR
VkCommandBuffer
VkCommandBufferAllocateInfo
VkCommandBufferBeginInfo
VkCommandBufferInheritanceConditionalRenderingInfoEXT
VkCommandBufferInheritanceInfo
VkCommandBufferInheritanceRenderingInfo
VkCommandBufferInheritanceRenderingInfoKHR
VkCommandBufferInheritanceRenderPassTransformInfoQCOM
VkCommandBufferInheritanceViewportScissorInfoNV
VkCommandBufferLevel
VkCommandBufferResetFlagBits
VkCommandBufferResetFlags
VkCommandBufferSubmitInfo
VkCommandBufferSubmitInfoKHR
VkCommandBufferUsageFlagBits
VkCommandBufferUsageFlags
VkCommandPool
VkCommandPoolCreateFlagBits
VkCommandPoolCreateFlags
VkCommandPoolCreateInfo
VkCommandPoolResetFlagBits
VkCommandPoolResetFlags
VkCommandPoolTrimFlags
VkCommandPoolTrimFlagsKHR
VkCompareOp
vkCompileDeferredNV
VkComponentMapping
VkComponentSwizzle
VkComponentTypeNV
VkCompositeAlphaFlagBitsKHR
VkCompositeAlphaFlagsKHR
VkComputePipelineCreateInfo
VkConditionalRenderingBeginInfoEXT
VkConditionalRenderingFlagBitsEXT
VkConditionalRenderingFlagsEXT
VkConformanceVersion
VkConformanceVersionKHR
VkConservativeRasterizationModeEXT
VkCooperativeMatrixPropertiesNV
VkCopyAccelerationStructureInfoKHR
vkCopyAccelerationStructureKHR
VkCopyAccelerationStructureModeKHR
VkCopyAccelerationStructureModeNV
VkCopyAccelerationStructureToMemoryInfoKHR
vkCopyAccelerationStructureToMemoryKHR
VkCopyBufferInfo2
VkCopyBufferInfo2KHR
VkCopyBufferToImageInfo2
VkCopyBufferToImageInfo2KHR
VkCopyCommandTransformInfoQCOM
VkCopyDescriptorSet
VkCopyImageInfo2
VkCopyImageInfo2KHR
VkCopyImageToBufferInfo2
VkCopyImageToBufferInfo2KHR
VkCopyMemoryToAccelerationStructureInfoKHR
vkCopyMemoryToAccelerationStructureKHR
VkCoverageModulationModeNV
VkCoverageReductionModeNV
vkCreateAccelerationStructureKHR
vkCreateAccelerationStructureNV
vkCreateAndroidSurfaceKHR
vkCreateBuffer
vkCreateBufferCollectionFUCHSIA
vkCreateBufferView
vkCreateCommandPool
vkCreateComputePipelines
vkCreateCuFunctionNVX
vkCreateCuModuleNVX
vkCreateDebugReportCallbackEXT
vkCreateDebugUtilsMessengerEXT
vkCreateDeferredOperationKHR
vkCreateDescriptorPool
vkCreateDescriptorSetLayout
vkCreateDescriptorUpdateTemplate
vkCreateDescriptorUpdateTemplateKHR
vkCreateDevice
vkCreateDirectFBSurfaceEXT
vkCreateDisplayModeKHR
vkCreateDisplayPlaneSurfaceKHR
vkCreateEvent
vkCreateFence
vkCreateFramebuffer
vkCreateGraphicsPipelines
vkCreateHeadlessSurfaceEXT
vkCreateImage
vkCreateImagePipeSurfaceFUCHSIA
vkCreateImageView
vkCreateIndirectCommandsLayoutNV
vkCreateInstance
vkCreateIOSSurfaceMVK
vkCreateMacOSSurfaceMVK
vkCreateMetalSurfaceEXT
vkCreatePipelineCache
vkCreatePipelineLayout
vkCreatePrivateDataSlot
vkCreatePrivateDataSlotEXT
vkCreateQueryPool
vkCreateRayTracingPipelinesKHR
vkCreateRayTracingPipelinesNV
vkCreateRenderPass
vkCreateRenderPass2
vkCreateRenderPass2KHR
vkCreateSampler
vkCreateSamplerYcbcrConversion
vkCreateSamplerYcbcrConversionKHR
vkCreateScreenSurfaceQNX
vkCreateSemaphore
vkCreateShaderModule
vkCreateSharedSwapchainsKHR
vkCreateStreamDescriptorSurfaceGGP
vkCreateSwapchainKHR
vkCreateValidationCacheEXT
vkCreateVideoSessionKHR
vkCreateVideoSessionParametersKHR
vkCreateViSurfaceNN
vkCreateWaylandSurfaceKHR
vkCreateWin32SurfaceKHR
vkCreateXcbSurfaceKHR
vkCreateXlibSurfaceKHR
VkCuFunctionCreateInfoNVX
VkCuFunctionNVX
VkCuLaunchInfoNVX
VkCullModeFlagBits
VkCullModeFlags
VkCuModuleCreateInfoNVX
VkCuModuleNVX
VkD3D12FenceSubmitInfoKHR
VkDebugMarkerMarkerInfoEXT
VkDebugMarkerObjectNameInfoEXT
VkDebugMarkerObjectTagInfoEXT
vkDebugMarkerSetObjectNameEXT
vkDebugMarkerSetObjectTagEXT
VkDebugReportCallbackCreateInfoEXT
VkDebugReportCallbackEXT
VkDebugReportFlagBitsEXT
VkDebugReportFlagsEXT
vkDebugReportMessageEXT
VkDebugReportObjectTypeEXT
VkDebugUtilsLabelEXT
VkDebugUtilsMessageSeverityFlagBitsEXT
VkDebugUtilsMessageSeverityFlagsEXT
VkDebugUtilsMessageTypeFlagBitsEXT
VkDebugUtilsMessageTypeFlagsEXT
VkDebugUtilsMessengerCallbackDataEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateInfoEXT
VkDebugUtilsMessengerEXT
VkDebugUtilsObjectNameInfoEXT
VkDebugUtilsObjectTagInfoEXT
VkDedicatedAllocationBufferCreateInfoNV
VkDedicatedAllocationImageCreateInfoNV
VkDedicatedAllocationMemoryAllocateInfoNV
vkDeferredOperationJoinKHR
VkDeferredOperationKHR
VkDependencyFlagBits
VkDependencyFlags
VkDependencyInfo
VkDependencyInfoKHR
VkDescriptorBindingFlagBits
VkDescriptorBindingFlagBitsEXT
VkDescriptorBindingFlags
VkDescriptorBindingFlagsEXT
VkDescriptorBufferInfo
VkDescriptorImageInfo
VkDescriptorPool
VkDescriptorPoolCreateFlagBits
VkDescriptorPoolCreateFlags
VkDescriptorPoolCreateInfo
VkDescriptorPoolInlineUniformBlockCreateInfo
VkDescriptorPoolInlineUniformBlockCreateInfoEXT
VkDescriptorPoolResetFlags
VkDescriptorPoolSize
VkDescriptorSet
VkDescriptorSetAllocateInfo
VkDescriptorSetBindingReferenceVALVE
VkDescriptorSetLayout
VkDescriptorSetLayoutBindingFlagsCreateInfo
VkDescriptorSetLayoutBindingFlagsCreateInfoEXT
VkDescriptorSetLayoutCreateFlagBits
VkDescriptorSetLayoutCreateFlags
VkDescriptorSetLayoutCreateInfo
VkDescriptorSetLayoutHostMappingInfoVALVE
VkDescriptorSetLayoutSupport
VkDescriptorSetLayoutSupportKHR
VkDescriptorSetVariableDescriptorCountAllocateInfo
VkDescriptorSetVariableDescriptorCountAllocateInfoEXT
VkDescriptorSetVariableDescriptorCountLayoutSupport
VkDescriptorSetVariableDescriptorCountLayoutSupportEXT
VkDescriptorType
VkDescriptorUpdateTemplate
VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateInfo
VkDescriptorUpdateTemplateCreateInfoKHR
VkDescriptorUpdateTemplateEntry
VkDescriptorUpdateTemplateEntryKHR
VkDescriptorUpdateTemplateKHR
VkDescriptorUpdateTemplateType
VkDescriptorUpdateTemplateTypeKHR
vkDestroyAccelerationStructureKHR
vkDestroyAccelerationStructureNV
vkDestroyBuffer
vkDestroyBufferCollectionFUCHSIA
vkDestroyBufferView
vkDestroyCommandPool
vkDestroyCuFunctionNVX
vkDestroyCuModuleNVX
vkDestroyDebugReportCallbackEXT
vkDestroyDebugUtilsMessengerEXT
vkDestroyDeferredOperationKHR
vkDestroyDescriptorPool
vkDestroyDescriptorSetLayout
vkDestroyDescriptorUpdateTemplate
vkDestroyDescriptorUpdateTemplateKHR
vkDestroyDevice
vkDestroyEvent
vkDestroyFence
vkDestroyFramebuffer
vkDestroyImage
vkDestroyImageView
vkDestroyIndirectCommandsLayoutNV
vkDestroyInstance
vkDestroyPipeline
vkDestroyPipelineCache
vkDestroyPipelineLayout
vkDestroyPrivateDataSlot
vkDestroyPrivateDataSlotEXT
vkDestroyQueryPool
vkDestroyRenderPass
vkDestroySampler
vkDestroySamplerYcbcrConversion
vkDestroySamplerYcbcrConversionKHR
vkDestroySemaphore
vkDestroyShaderModule
vkDestroySurfaceKHR
vkDestroySwapchainKHR
vkDestroyValidationCacheEXT
vkDestroyVideoSessionKHR
vkDestroyVideoSessionParametersKHR
VkDevice
VkDeviceAddress
VkDeviceBufferMemoryRequirements
VkDeviceBufferMemoryRequirementsKHR
VkDeviceCreateFlags
VkDeviceCreateInfo
VkDeviceDeviceMemoryReportCreateInfoEXT
VkDeviceDiagnosticsConfigCreateInfoNV
VkDeviceDiagnosticsConfigFlagBitsNV
VkDeviceDiagnosticsConfigFlagsNV
VkDeviceEventInfoEXT
VkDeviceEventTypeEXT
VkDeviceGroupBindSparseInfo
VkDeviceGroupBindSparseInfoKHR
VkDeviceGroupCommandBufferBeginInfo
VkDeviceGroupCommandBufferBeginInfoKHR
VkDeviceGroupDeviceCreateInfo
VkDeviceGroupDeviceCreateInfoKHR
VkDeviceGroupPresentCapabilitiesKHR
VkDeviceGroupPresentInfoKHR
VkDeviceGroupPresentModeFlagBitsKHR
VkDeviceGroupPresentModeFlagsKHR
VkDeviceGroupRenderPassBeginInfo
VkDeviceGroupRenderPassBeginInfoKHR
VkDeviceGroupSubmitInfo
VkDeviceGroupSubmitInfoKHR
VkDeviceGroupSwapchainCreateInfoKHR
VkDeviceImageMemoryRequirements
VkDeviceImageMemoryRequirementsKHR
VkDeviceMemoryOpaqueCaptureAddressInfo
VkDeviceMemoryOpaqueCaptureAddressInfoKHR
VkDeviceMemoryOverallocationCreateInfoAMD
VkDeviceMemoryReportCallbackDataEXT
VkDeviceMemoryReportEventTypeEXT
VkDeviceMemoryReportFlagsEXT
VkDeviceOrHostAddressConstKHR
VkDeviceOrHostAddressKHR
VkDevicePrivateDataCreateInfo
VkDevicePrivateDataCreateInfoEXT
VkDeviceQueueCreateFlagBits
VkDeviceQueueCreateFlags
VkDeviceQueueGlobalPriorityCreateInfoEXT
VkDeviceQueueGlobalPriorityCreateInfoKHR
VkDeviceQueueInfo2
vkDeviceWaitIdle
VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateInfoEXT
VkDiscardRectangleModeEXT
VkDispatchIndirectCommand
VkDisplayEventInfoEXT
VkDisplayEventTypeEXT
VkDisplayKHR
VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateInfoKHR
VkDisplayModeKHR
VkDisplayModeParametersKHR
VkDisplayModeProperties2KHR
VkDisplayModePropertiesKHR
VkDisplayNativeHdrSurfaceCapabilitiesAMD
VkDisplayPlaneAlphaFlagBitsKHR
VkDisplayPlaneAlphaFlagsKHR
VkDisplayPlaneCapabilities2KHR
VkDisplayPlaneCapabilitiesKHR
VkDisplayPlaneInfo2KHR
VkDisplayPlaneProperties2KHR
VkDisplayPlanePropertiesKHR
vkDisplayPowerControlEXT
VkDisplayPowerInfoEXT
VkDisplayPowerStateEXT
VkDisplayPresentInfoKHR
VkDisplayProperties2KHR
VkDisplayPropertiesKHR
VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateInfoKHR
VkDrawIndexedIndirectCommand
VkDrawIndirectCommand
VkDrawMeshTasksIndirectCommandNV
VkDriverId
VkDriverIdKHR
VkDrmFormatModifierProperties2EXT
VkDrmFormatModifierPropertiesEXT
VkDrmFormatModifierPropertiesList2EXT
VkDrmFormatModifierPropertiesListEXT
vkEndCommandBuffer
vkEnumerateDeviceExtensionProperties
vkEnumerateDeviceLayerProperties
vkEnumerateInstanceExtensionProperties
vkEnumerateInstanceLayerProperties
vkEnumerateInstanceVersion
vkEnumeratePhysicalDeviceGroups
vkEnumeratePhysicalDeviceGroupsKHR
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
vkEnumeratePhysicalDevices
VkEvent
VkEventCreateFlagBits
VkEventCreateFlags
VkEventCreateInfo
VkExportFenceCreateInfo
VkExportFenceCreateInfoKHR
VkExportFenceWin32HandleInfoKHR
VkExportMemoryAllocateInfo
VkExportMemoryAllocateInfoKHR
VkExportMemoryAllocateInfoNV
VkExportMemoryWin32HandleInfoKHR
VkExportMemoryWin32HandleInfoNV
VkExportSemaphoreCreateInfo
VkExportSemaphoreCreateInfoKHR
VkExportSemaphoreWin32HandleInfoKHR
VkExtensionProperties
VkExtent3D
VkExternalBufferProperties
VkExternalBufferPropertiesKHR
VkExternalFenceFeatureFlagBits
VkExternalFenceFeatureFlagBitsKHR
VkExternalFenceFeatureFlags
VkExternalFenceFeatureFlagsKHR
VkExternalFenceHandleTypeFlagBits
VkExternalFenceHandleTypeFlagBitsKHR
VkExternalFenceHandleTypeFlags
VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceProperties
VkExternalFencePropertiesKHR
VkExternalFormatANDROID
VkExternalImageFormatProperties
VkExternalImageFormatPropertiesKHR
VkExternalImageFormatPropertiesNV
VkExternalMemoryBufferCreateInfo
VkExternalMemoryBufferCreateInfoKHR
VkExternalMemoryFeatureFlagBits
VkExternalMemoryFeatureFlagBitsKHR
VkExternalMemoryFeatureFlagBitsNV
VkExternalMemoryFeatureFlags
VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsNV
VkExternalMemoryHandleTypeFlagBits
VkExternalMemoryHandleTypeFlagBitsKHR
VkExternalMemoryHandleTypeFlagBitsNV
VkExternalMemoryHandleTypeFlags
VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsNV
VkExternalMemoryImageCreateInfo
VkExternalMemoryImageCreateInfoKHR
VkExternalMemoryImageCreateInfoNV
VkExternalMemoryProperties
VkExternalMemoryPropertiesKHR
VkExternalSemaphoreFeatureFlagBits
VkExternalSemaphoreFeatureFlagBitsKHR
VkExternalSemaphoreFeatureFlags
VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreHandleTypeFlagBits
VkExternalSemaphoreHandleTypeFlagBitsKHR
VkExternalSemaphoreHandleTypeFlags
VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreProperties
VkExternalSemaphorePropertiesKHR
VkFence
VkFenceCreateFlagBits
VkFenceCreateFlags
VkFenceCreateInfo
VkFenceGetFdInfoKHR
VkFenceGetWin32HandleInfoKHR
VkFenceImportFlagBits
VkFenceImportFlagBitsKHR
VkFenceImportFlags
VkFenceImportFlagsKHR
VkFilter
VkFilterCubicImageViewImageFormatPropertiesEXT
VkFlags
VkFlags64
vkFlushMappedMemoryRanges
VkFormat
VkFormatFeatureFlagBits
VkFormatFeatureFlagBits2
VkFormatFeatureFlagBits2KHR
VkFormatFeatureFlags
VkFormatFeatureFlags2
VkFormatFeatureFlags2KHR
VkFormatProperties
VkFormatProperties2
VkFormatProperties2KHR
VkFormatProperties3
VkFormatProperties3KHR
VkFragmentShadingRateAttachmentInfoKHR
VkFragmentShadingRateCombinerOpKHR
VkFragmentShadingRateNV
VkFragmentShadingRateTypeNV
VkFramebuffer
VkFramebufferAttachmentImageInfo
VkFramebufferAttachmentImageInfoKHR
VkFramebufferAttachmentsCreateInfo
VkFramebufferAttachmentsCreateInfoKHR
VkFramebufferCreateFlagBits
VkFramebufferCreateFlags
VkFramebufferCreateInfo
VkFramebufferMixedSamplesCombinationNV
vkFreeCommandBuffers
vkFreeDescriptorSets
vkFreeMemory
VkFrontFace
VkFullScreenExclusiveEXT
VkGeneratedCommandsInfoNV
VkGeneratedCommandsMemoryRequirementsInfoNV
VkGeometryAABBNV
VkGeometryDataNV
VkGeometryFlagBitsKHR
VkGeometryFlagBitsNV
VkGeometryFlagsKHR
VkGeometryFlagsNV
VkGeometryInstanceFlagBitsKHR
VkGeometryInstanceFlagBitsNV
VkGeometryInstanceFlagsKHR
VkGeometryInstanceFlagsNV
VkGeometryNV
VkGeometryTrianglesNV
VkGeometryTypeKHR
VkGeometryTypeNV
vkGetAccelerationStructureBuildSizesKHR
vkGetAccelerationStructureDeviceAddressKHR
vkGetAccelerationStructureHandleNV
vkGetAccelerationStructureMemoryRequirementsNV
vkGetAndroidHardwareBufferPropertiesANDROID
vkGetBufferCollectionPropertiesFUCHSIA
vkGetBufferDeviceAddress
vkGetBufferDeviceAddressEXT
vkGetBufferDeviceAddressKHR
vkGetBufferMemoryRequirements
vkGetBufferMemoryRequirements2
vkGetBufferMemoryRequirements2KHR
vkGetBufferOpaqueCaptureAddress
vkGetBufferOpaqueCaptureAddressKHR
vkGetCalibratedTimestampsEXT
vkGetDeferredOperationMaxConcurrencyKHR
vkGetDeferredOperationResultKHR
vkGetDescriptorSetHostMappingVALVE
vkGetDescriptorSetLayoutHostMappingInfoVALVE
vkGetDescriptorSetLayoutSupport
vkGetDescriptorSetLayoutSupportKHR
vkGetDeviceAccelerationStructureCompatibilityKHR
vkGetDeviceBufferMemoryRequirements
vkGetDeviceBufferMemoryRequirementsKHR
vkGetDeviceGroupPeerMemoryFeatures
vkGetDeviceGroupPeerMemoryFeaturesKHR
vkGetDeviceGroupPresentCapabilitiesKHR
vkGetDeviceGroupSurfacePresentModes2EXT
vkGetDeviceGroupSurfacePresentModesKHR
vkGetDeviceImageMemoryRequirements
vkGetDeviceImageMemoryRequirementsKHR
vkGetDeviceImageSparseMemoryRequirements
vkGetDeviceImageSparseMemoryRequirementsKHR
vkGetDeviceMemoryCommitment
vkGetDeviceMemoryOpaqueCaptureAddress
vkGetDeviceMemoryOpaqueCaptureAddressKHR
vkGetDeviceProcAddr
vkGetDeviceQueue
vkGetDeviceQueue2
vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI
vkGetDisplayModeProperties2KHR
vkGetDisplayModePropertiesKHR
vkGetDisplayPlaneCapabilities2KHR
vkGetDisplayPlaneCapabilitiesKHR
vkGetDisplayPlaneSupportedDisplaysKHR
vkGetDrmDisplayEXT
vkGetEventStatus
vkGetFenceFdKHR
vkGetFenceStatus
vkGetFenceWin32HandleKHR
vkGetGeneratedCommandsMemoryRequirementsNV
vkGetImageDrmFormatModifierPropertiesEXT
vkGetImageMemoryRequirements
vkGetImageMemoryRequirements2
vkGetImageMemoryRequirements2KHR
vkGetImageSparseMemoryRequirements
vkGetImageSparseMemoryRequirements2
vkGetImageSparseMemoryRequirements2KHR
vkGetImageSubresourceLayout
vkGetImageViewAddressNVX
vkGetImageViewHandleNVX
vkGetInstanceProcAddr
vkGetInstanceProcAddress
vkGetMemoryAndroidHardwareBufferANDROID
vkGetMemoryFdKHR
vkGetMemoryFdPropertiesKHR
vkGetMemoryHostPointerPropertiesEXT
vkGetMemoryRemoteAddressNV
vkGetMemoryWin32HandleKHR
vkGetMemoryWin32HandleNV
vkGetMemoryWin32HandlePropertiesKHR
vkGetMemoryZirconHandleFUCHSIA
vkGetMemoryZirconHandlePropertiesFUCHSIA
vkGetPastPresentationTimingGOOGLE
vkGetPerformanceParameterINTEL
vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
vkGetPhysicalDeviceCooperativeMatrixPropertiesNV
vkGetPhysicalDeviceDirectFBPresentationSupportEXT
vkGetPhysicalDeviceDisplayPlaneProperties2KHR
vkGetPhysicalDeviceDisplayPlanePropertiesKHR
vkGetPhysicalDeviceDisplayProperties2KHR
vkGetPhysicalDeviceDisplayPropertiesKHR
vkGetPhysicalDeviceExternalBufferProperties
vkGetPhysicalDeviceExternalBufferPropertiesKHR
vkGetPhysicalDeviceExternalFenceProperties
vkGetPhysicalDeviceExternalFencePropertiesKHR
vkGetPhysicalDeviceExternalImageFormatPropertiesNV
vkGetPhysicalDeviceExternalSemaphoreProperties
vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
vkGetPhysicalDeviceFeatures
vkGetPhysicalDeviceFeatures2
vkGetPhysicalDeviceFeatures2KHR
vkGetPhysicalDeviceFormatProperties
vkGetPhysicalDeviceFormatProperties2
vkGetPhysicalDeviceFormatProperties2KHR
vkGetPhysicalDeviceFragmentShadingRatesKHR
vkGetPhysicalDeviceImageFormatProperties
vkGetPhysicalDeviceImageFormatProperties2
vkGetPhysicalDeviceImageFormatProperties2KHR
vkGetPhysicalDeviceMemoryProperties
vkGetPhysicalDeviceMemoryProperties2
vkGetPhysicalDeviceMemoryProperties2KHR
vkGetPhysicalDeviceMultisamplePropertiesEXT
vkGetPhysicalDevicePresentRectanglesKHR
vkGetPhysicalDeviceProperties
vkGetPhysicalDeviceProperties2
vkGetPhysicalDeviceProperties2KHR
vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
vkGetPhysicalDeviceQueueFamilyProperties
vkGetPhysicalDeviceQueueFamilyProperties2
vkGetPhysicalDeviceQueueFamilyProperties2KHR
vkGetPhysicalDeviceScreenPresentationSupportQNX
vkGetPhysicalDeviceSparseImageFormatProperties
vkGetPhysicalDeviceSparseImageFormatProperties2
vkGetPhysicalDeviceSparseImageFormatProperties2KHR
vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
vkGetPhysicalDeviceSurfaceCapabilities2EXT
vkGetPhysicalDeviceSurfaceCapabilities2KHR
vkGetPhysicalDeviceSurfaceCapabilitiesKHR
vkGetPhysicalDeviceSurfaceFormats2KHR
vkGetPhysicalDeviceSurfaceFormatsKHR
vkGetPhysicalDeviceSurfacePresentModes2EXT
vkGetPhysicalDeviceSurfacePresentModesKHR
vkGetPhysicalDeviceSurfaceSupportKHR
vkGetPhysicalDeviceToolProperties
vkGetPhysicalDeviceToolPropertiesEXT
vkGetPhysicalDeviceVideoCapabilitiesKHR
vkGetPhysicalDeviceVideoFormatPropertiesKHR
vkGetPhysicalDeviceWaylandPresentationSupportKHR
vkGetPhysicalDeviceWin32PresentationSupportKHR
vkGetPhysicalDeviceXcbPresentationSupportKHR
vkGetPhysicalDeviceXlibPresentationSupportKHR
vkGetPipelineCacheData
vkGetPipelineExecutableInternalRepresentationsKHR
vkGetPipelineExecutablePropertiesKHR
vkGetPipelineExecutableStatisticsKHR
vkGetPrivateData
vkGetPrivateDataEXT
vkGetQueryPoolResults
vkGetQueueCheckpointData2NV
vkGetQueueCheckpointDataNV
vkGetRandROutputDisplayEXT
vkGetRayTracingCaptureReplayShaderGroupHandlesKHR
vkGetRayTracingShaderGroupHandlesKHR
vkGetRayTracingShaderGroupHandlesNV
vkGetRayTracingShaderGroupStackSizeKHR
vkGetRefreshCycleDurationGOOGLE
vkGetRenderAreaGranularity
vkGetSemaphoreCounterValue
vkGetSemaphoreCounterValueKHR
vkGetSemaphoreFdKHR
vkGetSemaphoreWin32HandleKHR
vkGetSemaphoreZirconHandleFUCHSIA
vkGetShaderInfoAMD
vkGetSwapchainCounterEXT
vkGetSwapchainImagesKHR
vkGetSwapchainStatusKHR
vkGetValidationCacheDataEXT
vkGetVideoSessionMemoryRequirementsKHR
vkGetWinrtDisplayNV
VkGraphicsPipelineCreateInfo
VkGraphicsPipelineLibraryCreateInfoEXT
VkGraphicsPipelineLibraryFlagBitsEXT
VkGraphicsPipelineLibraryFlagsEXT
VkGraphicsPipelineShaderGroupsCreateInfoNV
VkGraphicsShaderGroupCreateInfoNV
VkHdrMetadataEXT
VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateInfoEXT
VkImageAspectFlagBits
VkImageAspectFlags
VkImageBlit
VkImageBlit2
VkImageBlit2KHR
VkImageConstraintsInfoFlagBitsFUCHSIA
VkImageConstraintsInfoFlagsFUCHSIA
VkImageConstraintsInfoFUCHSIA
VkImageCopy
VkImageCopy2
VkImageCopy2KHR
VkImageCreateFlagBits
VkImageCreateFlags
VkImageCreateInfo
VkImageDrmFormatModifierExplicitCreateInfoEXT
VkImageDrmFormatModifierListCreateInfoEXT
VkImageDrmFormatModifierPropertiesEXT
VkImageFormatConstraintsFlagsFUCHSIA
VkImageFormatConstraintsInfoFUCHSIA
VkImageFormatListCreateInfo
VkImageFormatListCreateInfoKHR
VkImageFormatProperties
VkImageFormatProperties2
VkImageFormatProperties2KHR
VkImageLayout
VkImageMemoryBarrier
VkImageMemoryBarrier2
VkImageMemoryBarrier2KHR
VkImageMemoryRequirementsInfo2
VkImageMemoryRequirementsInfo2KHR
VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateInfoFUCHSIA
VkImagePlaneMemoryRequirementsInfo
VkImagePlaneMemoryRequirementsInfoKHR
VkImageResolve
VkImageResolve2
VkImageResolve2KHR
VkImageSparseMemoryRequirementsInfo2
VkImageSparseMemoryRequirementsInfo2KHR
VkImageStencilUsageCreateInfo
VkImageStencilUsageCreateInfoEXT
VkImageSubresource
VkImageSubresourceLayers
VkImageSubresourceRange
VkImageSwapchainCreateInfoKHR
VkImageType
VkImageUsageFlagBits
VkImageViewAddressPropertiesNVX
VkImageViewASTCDecodeModeEXT
VkImageViewCreateFlagBits
VkImageViewCreateFlags
VkImageViewHandleInfoNVX
VkImageViewMinLodCreateInfoEXT
VkImageViewType
VkImageViewUsageCreateInfo
VkImageViewUsageCreateInfoKHR
VkImportAndroidHardwareBufferInfoANDROID
VkImportFenceFdInfoKHR
vkImportFenceFdKHR
VkImportFenceWin32HandleInfoKHR
vkImportFenceWin32HandleKHR
VkImportMemoryBufferCollectionFUCHSIA
VkImportMemoryFdInfoKHR
VkImportMemoryHostPointerInfoEXT
VkImportMemoryWin32HandleInfoKHR
VkImportMemoryWin32HandleInfoNV
VkImportMemoryZirconHandleInfoFUCHSIA
VkImportSemaphoreFdInfoKHR
vkImportSemaphoreFdKHR
VkImportSemaphoreWin32HandleInfoKHR
vkImportSemaphoreWin32HandleKHR
vkImportSemaphoreZirconHandleFUCHSIA
VkImportSemaphoreZirconHandleInfoFUCHSIA
VkIndexType
VkIndirectCommandsLayoutCreateInfoNV
VkIndirectCommandsLayoutNV
VkIndirectCommandsLayoutTokenNV
VkIndirectCommandsLayoutUsageFlagBitsNV
VkIndirectCommandsLayoutUsageFlagsNV
VkIndirectCommandsStreamNV
VkIndirectCommandsTokenTypeNV
VkIndirectStateFlagBitsNV
VkIndirectStateFlagsNV
VkInitializePerformanceApiInfoINTEL
vkInitializePerformanceApiINTEL
VkInputAttachmentAspectReference
VkInputAttachmentAspectReferenceKHR
VkInstanceCreateFlagBits
VkInstanceCreateFlags
VkInstanceCreateInfo
VkInternalAllocationType
vkInvalidateMappedMemoryRanges
VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateInfoMVK
VkLineRasterizationModeEXT
VkLogicOp
VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateInfoMVK
vkMapMemory
VkMappedMemoryRange
VkMemoryAllocateFlagBits
VkMemoryAllocateFlagBitsKHR
VkMemoryAllocateFlags
VkMemoryAllocateFlagsInfo
VkMemoryAllocateFlagsInfoKHR
VkMemoryAllocateFlagsKHR
VkMemoryAllocateInfo
VkMemoryBarrier
VkMemoryBarrier2
VkMemoryBarrier2KHR
VkMemoryDedicatedAllocateInfo
VkMemoryDedicatedAllocateInfoKHR
VkMemoryDedicatedRequirements
VkMemoryDedicatedRequirementsKHR
VkMemoryFdPropertiesKHR
VkMemoryGetAndroidHardwareBufferInfoANDROID
VkMemoryGetFdInfoKHR
VkMemoryGetRemoteAddressInfoNV
VkMemoryGetWin32HandleInfoKHR
VkMemoryGetZirconHandleInfoFUCHSIA
VkMemoryHeap
VkMemoryHeapFlagBits
VkMemoryHeapFlags
VkMemoryHostPointerPropertiesEXT
VkMemoryMapFlags
VkMemoryOpaqueCaptureAddressAllocateInfo
VkMemoryOpaqueCaptureAddressAllocateInfoKHR
VkMemoryOverallocationBehaviorAMD
VkMemoryPriorityAllocateInfoEXT
VkMemoryPropertyFlagBits
VkMemoryPropertyFlags
VkMemoryRequirements
VkMemoryRequirements2
VkMemoryRequirements2KHR
VkMemoryType
VkMemoryWin32HandlePropertiesKHR
VkMemoryZirconHandlePropertiesFUCHSIA
vkMergePipelineCaches
vkMergeValidationCachesEXT
VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateInfoEXT
VkMultiDrawIndexedInfoEXT
VkMultiDrawInfoEXT
VkMultisamplePropertiesEXT
VkMultiviewPerViewAttributesInfoNVX
VkMutableDescriptorTypeCreateInfoVALVE
VkMutableDescriptorTypeListVALVE
VkObjectType
VkOffset2D
VkOffset3D
VkPastPresentationTimingGOOGLE
VkPeerMemoryFeatureFlagBits
VkPeerMemoryFeatureFlagBitsKHR
VkPeerMemoryFeatureFlags
VkPeerMemoryFeatureFlagsKHR
VkPerformanceConfigurationAcquireInfoINTEL
VkPerformanceConfigurationINTEL
VkPerformanceConfigurationTypeINTEL
VkPerformanceCounterDescriptionFlagBitsKHR
VkPerformanceCounterDescriptionFlagsKHR
VkPerformanceCounterDescriptionKHR
VkPerformanceCounterKHR
VkPerformanceCounterResultKHR
VkPerformanceCounterScopeKHR
VkPerformanceCounterStorageKHR
VkPerformanceCounterUnitKHR
VkPerformanceMarkerInfoINTEL
VkPerformanceOverrideInfoINTEL
VkPerformanceOverrideTypeINTEL
VkPerformanceParameterTypeINTEL
VkPerformanceQuerySubmitInfoKHR
VkPerformanceStreamMarkerInfoINTEL
VkPerformanceValueDataINTEL
VkPerformanceValueINTEL
VkPerformanceValueTypeINTEL
VkPhysicalDevice8BitStorageFeatures
VkPhysicalDevice8BitStorageFeaturesKHR
VkPhysicalDevice16BitStorageFeatures
VkPhysicalDevice16BitStorageFeaturesKHR
VkPhysicalDevice4444FormatsFeaturesEXT
VkPhysicalDeviceAccelerationStructureFeaturesKHR
VkPhysicalDeviceAccelerationStructurePropertiesKHR
VkPhysicalDeviceASTCDecodeFeaturesEXT
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
VkPhysicalDeviceBorderColorSwizzleFeaturesEXT
VkPhysicalDeviceBufferAddressFeaturesEXT
VkPhysicalDeviceBufferDeviceAddressFeatures
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT
VkPhysicalDeviceBufferDeviceAddressFeaturesKHR
VkPhysicalDeviceCoherentMemoryFeaturesAMD
VkPhysicalDeviceColorWriteEnableFeaturesEXT
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV
VkPhysicalDeviceConditionalRenderingFeaturesEXT
VkPhysicalDeviceConservativeRasterizationPropertiesEXT
VkPhysicalDeviceCooperativeMatrixFeaturesNV
VkPhysicalDeviceCooperativeMatrixPropertiesNV
VkPhysicalDeviceCornerSampledImageFeaturesNV
VkPhysicalDeviceCoverageReductionModeFeaturesNV
VkPhysicalDeviceCustomBorderColorFeaturesEXT
VkPhysicalDeviceCustomBorderColorPropertiesEXT
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
VkPhysicalDeviceDepthClipControlFeaturesEXT
VkPhysicalDeviceDepthClipEnableFeaturesEXT
VkPhysicalDeviceDepthStencilResolveProperties
VkPhysicalDeviceDepthStencilResolvePropertiesKHR
VkPhysicalDeviceDescriptorIndexingFeatures
VkPhysicalDeviceDescriptorIndexingFeaturesEXT
VkPhysicalDeviceDescriptorIndexingProperties
VkPhysicalDeviceDescriptorIndexingPropertiesEXT
VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT
VkPhysicalDeviceDiagnosticsConfigFeaturesNV
VkPhysicalDeviceDiscardRectanglePropertiesEXT
VkPhysicalDeviceDriverProperties
VkPhysicalDeviceDriverPropertiesKHR
VkPhysicalDeviceDrmPropertiesEXT
VkPhysicalDeviceDynamicRenderingFeatures
VkPhysicalDeviceDynamicRenderingFeaturesKHR
VkPhysicalDeviceExclusiveScissorFeaturesNV
VkPhysicalDeviceExtendedDynamicState2FeaturesEXT
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT
VkPhysicalDeviceExternalBufferInfo
VkPhysicalDeviceExternalBufferInfoKHR
VkPhysicalDeviceExternalFenceInfo
VkPhysicalDeviceExternalFenceInfoKHR
VkPhysicalDeviceExternalImageFormatInfo
VkPhysicalDeviceExternalImageFormatInfoKHR
VkPhysicalDeviceExternalMemoryHostPropertiesEXT
VkPhysicalDeviceExternalMemoryRDMAFeaturesNV
VkPhysicalDeviceExternalSemaphoreInfo
VkPhysicalDeviceExternalSemaphoreInfoKHR
VkPhysicalDeviceFeatures2
VkPhysicalDeviceFeatures2KHR
VkPhysicalDeviceFloat16Int8FeaturesKHR
VkPhysicalDeviceFloatControlsProperties
VkPhysicalDeviceFloatControlsPropertiesKHR
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT
VkPhysicalDeviceFragmentDensityMapFeaturesEXT
VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
VkPhysicalDeviceFragmentDensityMapPropertiesEXT
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV
VkPhysicalDeviceFragmentShadingRateFeaturesKHR
VkPhysicalDeviceFragmentShadingRateKHR
VkPhysicalDeviceFragmentShadingRatePropertiesKHR
VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT
VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR
VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT
VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
VkPhysicalDeviceGroupProperties
VkPhysicalDeviceGroupPropertiesKHR
VkPhysicalDeviceHostQueryResetFeatures
VkPhysicalDeviceHostQueryResetFeaturesEXT
VkPhysicalDeviceIDProperties
VkPhysicalDeviceIDPropertiesKHR
VkPhysicalDeviceImage2DViewOf3DFeaturesEXT
VkPhysicalDeviceImageDrmFormatModifierInfoEXT
VkPhysicalDeviceImageFormatInfo2
VkPhysicalDeviceImageFormatInfo2KHR
VkPhysicalDeviceImagelessFramebufferFeatures
VkPhysicalDeviceImagelessFramebufferFeaturesKHR
VkPhysicalDeviceImageRobustnessFeatures
VkPhysicalDeviceImageRobustnessFeaturesEXT
VkPhysicalDeviceImageViewImageFormatInfoEXT
VkPhysicalDeviceImageViewMinLodFeaturesEXT
VkPhysicalDeviceIndexTypeUint8FeaturesEXT
VkPhysicalDeviceInheritedViewportScissorFeaturesNV
VkPhysicalDeviceInlineUniformBlockFeatures
VkPhysicalDeviceInlineUniformBlockFeaturesEXT
VkPhysicalDeviceInlineUniformBlockProperties
VkPhysicalDeviceInlineUniformBlockPropertiesEXT
VkPhysicalDeviceInvocationMaskFeaturesHUAWEI
VkPhysicalDeviceLinearColorAttachmentFeaturesNV
VkPhysicalDeviceLineRasterizationFeaturesEXT
VkPhysicalDeviceLineRasterizationPropertiesEXT
VkPhysicalDeviceMaintenance3Properties
VkPhysicalDeviceMaintenance3PropertiesKHR
VkPhysicalDeviceMaintenance4Features
VkPhysicalDeviceMaintenance4FeaturesKHR
VkPhysicalDeviceMaintenance4Properties
VkPhysicalDeviceMaintenance4PropertiesKHR
VkPhysicalDeviceMemoryBudgetPropertiesEXT
VkPhysicalDeviceMemoryPriorityFeaturesEXT
VkPhysicalDeviceMemoryProperties
VkPhysicalDeviceMemoryProperties2
VkPhysicalDeviceMemoryProperties2KHR
VkPhysicalDeviceMeshShaderFeaturesNV
VkPhysicalDeviceMeshShaderPropertiesNV
VkPhysicalDeviceMultiDrawFeaturesEXT
VkPhysicalDeviceMultiDrawPropertiesEXT
VkPhysicalDeviceMultiviewFeatures
VkPhysicalDeviceMultiviewFeaturesKHR
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
VkPhysicalDeviceMultiviewProperties
VkPhysicalDeviceMultiviewPropertiesKHR
VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE
VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
VkPhysicalDevicePCIBusInfoPropertiesEXT
VkPhysicalDevicePerformanceQueryFeaturesKHR
VkPhysicalDevicePerformanceQueryPropertiesKHR
VkPhysicalDevicePipelineCreationCacheControlFeatures
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR
VkPhysicalDevicePointClippingProperties
VkPhysicalDevicePointClippingPropertiesKHR
VkPhysicalDevicePortabilitySubsetFeaturesKHR
VkPhysicalDevicePortabilitySubsetPropertiesKHR
VkPhysicalDevicePresentIdFeaturesKHR
VkPhysicalDevicePresentWaitFeaturesKHR
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT
VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
VkPhysicalDevicePrivateDataFeatures
VkPhysicalDevicePrivateDataFeaturesEXT
VkPhysicalDeviceProperties2
VkPhysicalDeviceProperties2KHR
VkPhysicalDeviceProtectedMemoryFeatures
VkPhysicalDeviceProtectedMemoryProperties
VkPhysicalDeviceProvokingVertexFeaturesEXT
VkPhysicalDeviceProvokingVertexPropertiesEXT
VkPhysicalDevicePushDescriptorPropertiesKHR
VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
VkPhysicalDeviceRayQueryFeaturesKHR
VkPhysicalDeviceRayTracingMotionBlurFeaturesNV
VkPhysicalDeviceRayTracingPipelineFeaturesKHR
VkPhysicalDeviceRayTracingPipelinePropertiesKHR
VkPhysicalDeviceRayTracingPropertiesNV
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV
VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT
VkPhysicalDeviceRobustness2FeaturesEXT
VkPhysicalDeviceRobustness2PropertiesEXT
VkPhysicalDeviceSampleLocationsPropertiesEXT
VkPhysicalDeviceSamplerFilterMinmaxProperties
VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT
VkPhysicalDeviceSamplerYcbcrConversionFeatures
VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR
VkPhysicalDeviceScalarBlockLayoutFeatures
VkPhysicalDeviceScalarBlockLayoutFeaturesEXT
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR
VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT
VkPhysicalDeviceShaderAtomicInt64Features
VkPhysicalDeviceShaderAtomicInt64FeaturesKHR
VkPhysicalDeviceShaderClockFeaturesKHR
VkPhysicalDeviceShaderCoreProperties2AMD
VkPhysicalDeviceShaderCorePropertiesAMD
VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
VkPhysicalDeviceShaderDrawParameterFeatures
VkPhysicalDeviceShaderDrawParametersFeatures
VkPhysicalDeviceShaderFloat16Int8Features
VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
VkPhysicalDeviceShaderImageFootprintFeaturesNV
VkPhysicalDeviceShaderIntegerDotProductFeatures
VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR
VkPhysicalDeviceShaderIntegerDotProductProperties
VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
VkPhysicalDeviceShaderTerminateInvocationFeatures
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR
VkPhysicalDeviceShadingRateImageFeaturesNV
VkPhysicalDeviceShadingRateImagePropertiesNV
VkPhysicalDeviceSparseImageFormatInfo2
VkPhysicalDeviceSparseImageFormatInfo2KHR
VkPhysicalDeviceSparseProperties
VkPhysicalDeviceSubgroupProperties
VkPhysicalDeviceSubgroupSizeControlFeatures
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT
VkPhysicalDeviceSubgroupSizeControlProperties
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT
VkPhysicalDeviceSubpassShadingFeaturesHUAWEI
VkPhysicalDeviceSubpassShadingPropertiesHUAWEI
VkPhysicalDeviceSurfaceInfo2KHR
VkPhysicalDeviceSynchronization2Features
VkPhysicalDeviceSynchronization2FeaturesKHR
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT
VkPhysicalDeviceTexelBufferAlignmentProperties
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT
VkPhysicalDeviceTextureCompressionASTCHDRFeatures
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
VkPhysicalDeviceTimelineSemaphoreFeatures
VkPhysicalDeviceTimelineSemaphoreFeaturesKHR
VkPhysicalDeviceTimelineSemaphoreProperties
VkPhysicalDeviceTimelineSemaphorePropertiesKHR
VkPhysicalDeviceToolProperties
VkPhysicalDeviceToolPropertiesEXT
VkPhysicalDeviceTransformFeedbackFeaturesEXT
VkPhysicalDeviceTransformFeedbackPropertiesEXT
VkPhysicalDeviceType
VkPhysicalDeviceUniformBufferStandardLayoutFeatures
VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
VkPhysicalDeviceVariablePointerFeatures
VkPhysicalDeviceVariablePointerFeaturesKHR
VkPhysicalDeviceVariablePointersFeatures
VkPhysicalDeviceVariablePointersFeaturesKHR
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT
VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT
VkPhysicalDeviceVideoFormatInfoKHR
VkPhysicalDeviceVulkan11Features
VkPhysicalDeviceVulkan11Properties
VkPhysicalDeviceVulkan12Features
VkPhysicalDeviceVulkan12Properties
VkPhysicalDeviceVulkan13Features
VkPhysicalDeviceVulkan13Properties
VkPhysicalDeviceVulkanMemoryModelFeatures
VkPhysicalDeviceVulkanMemoryModelFeaturesKHR
VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
VkPipelineBindPoint
VkPipelineCache
VkPipelineCacheCreateFlagBits
VkPipelineCacheCreateFlags
VkPipelineCacheCreateInfo
VkPipelineCacheHeaderVersion
VkPipelineCacheHeaderVersionOne
VkPipelineColorBlendAdvancedStateCreateInfoEXT
VkPipelineColorBlendAttachmentState
VkPipelineColorBlendStateCreateFlagBits
VkPipelineColorBlendStateCreateFlags
VkPipelineColorWriteCreateInfoEXT
VkPipelineCompilerControlCreateInfoAMD
VkPipelineCompilerControlFlagBitsAMD
VkPipelineCompilerControlFlagsAMD
VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateInfoNV
VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateInfoNV
VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateInfoNV
VkPipelineCreateFlagBits
VkPipelineCreateFlags
VkPipelineCreationFeedback
VkPipelineCreationFeedbackCreateInfo
VkPipelineCreationFeedbackCreateInfoEXT
VkPipelineCreationFeedbackEXT
VkPipelineCreationFeedbackFlagBits
VkPipelineCreationFeedbackFlagBitsEXT
VkPipelineCreationFeedbackFlags
VkPipelineCreationFeedbackFlagsEXT
VkPipelineDepthStencilStateCreateFlagBits
VkPipelineDepthStencilStateCreateFlags
VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateInfoEXT
VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateInfo
VkPipelineExecutableInfoKHR
VkPipelineExecutableInternalRepresentationKHR
VkPipelineExecutablePropertiesKHR
VkPipelineExecutableStatisticFormatKHR
VkPipelineExecutableStatisticKHR
VkPipelineExecutableStatisticValueKHR
VkPipelineFragmentShadingRateEnumStateCreateInfoNV
VkPipelineFragmentShadingRateStateCreateInfoKHR
VkPipelineInfoKHR
VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateInfo
VkPipelineLayout
VkPipelineLayoutCreateFlagBits
VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateInfo
VkPipelineLibraryCreateInfoKHR
VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateInfo
VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateInfoEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateInfoEXT
VkPipelineRasterizationLineStateCreateInfoEXT
VkPipelineRasterizationProvokingVertexStateCreateInfoEXT
VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateInfo
VkPipelineRasterizationStateRasterizationOrderAMD
VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateInfoEXT
VkPipelineRenderingCreateInfo
VkPipelineRenderingCreateInfoKHR
VkPipelineRepresentativeFragmentTestStateCreateInfoNV
VkPipelineSampleLocationsStateCreateInfoEXT
VkPipelineShaderStageCreateFlagBits
VkPipelineShaderStageCreateFlags
VkPipelineShaderStageCreateInfo
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
VkPipelineStageFlagBits
VkPipelineStageFlagBits2
VkPipelineStageFlagBits2KHR
VkPipelineStageFlags
VkPipelineStageFlags2
VkPipelineStageFlags2KHR
VkPipelineTessellationDomainOriginStateCreateInfo
VkPipelineTessellationDomainOriginStateCreateInfoKHR
VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateInfo
VkPipelineVertexInputDivisorStateCreateInfoEXT
VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateInfo
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV
VkPipelineViewportDepthClipControlCreateInfoEXT
VkPipelineViewportExclusiveScissorStateCreateInfoNV
VkPipelineViewportShadingRateImageStateCreateInfoNV
VkPipelineViewportStateCreateFlags
VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateInfoNV
VkPipelineViewportWScalingStateCreateInfoNV
VkPointClippingBehavior
VkPointClippingBehaviorKHR
VkPolygonMode
VkPresentFrameTokenGGP
VkPresentIdKHR
VkPresentInfoKHR
VkPresentRegionKHR
VkPresentRegionsKHR
VkPresentTimeGOOGLE
VkPresentTimesInfoGOOGLE
VkPrimitiveTopology
VkPrivateDataSlot
VkPrivateDataSlotCreateFlagBits
VkPrivateDataSlotCreateFlagBitsEXT
VkPrivateDataSlotCreateFlags
VkPrivateDataSlotCreateFlagsEXT
VkPrivateDataSlotCreateInfo
VkPrivateDataSlotCreateInfoEXT
VkPrivateDataSlotEXT
VkProtectedSubmitInfo
VkProvokingVertexModeEXT
VkPushConstantRange
VkQueryControlFlagBits
VkQueryControlFlags
VkQueryPipelineStatisticFlagBits
VkQueryPipelineStatisticFlags
VkQueryPool
VkQueryPoolCreateFlags
VkQueryPoolCreateInfo
VkQueryPoolCreateInfoINTEL
VkQueryPoolPerformanceCreateInfoKHR
VkQueryPoolPerformanceQueryCreateInfoINTEL
VkQueryPoolSamplingModeINTEL
VkQueryResultFlagBits
VkQueryResultFlags
VkQueryResultStatusKHR
VkQueryType
vkQueueBeginDebugUtilsLabelEXT
vkQueueBindSparse
vkQueueEndDebugUtilsLabelEXT
VkQueueFamilyCheckpointProperties2NV
VkQueueFamilyCheckpointPropertiesNV
VkQueueFamilyGlobalPriorityPropertiesEXT
VkQueueFamilyGlobalPriorityPropertiesKHR
VkQueueFamilyProperties2
VkQueueFamilyProperties2KHR
VkQueueFamilyQueryResultStatusProperties2KHR
VkQueueFlagBits
VkQueueFlags
VkQueueGlobalPriorityEXT
VkQueueGlobalPriorityKHR
vkQueueInsertDebugUtilsLabelEXT
vkQueuePresentKHR
vkQueueSetPerformanceConfigurationINTEL
vkQueueSubmit
vkQueueSubmit2
vkQueueSubmit2KHR

vkQueueWaitIdle
VkRasterizationOrderAMD
VkRayTracingPipelineCreateInfoKHR
VkRayTracingPipelineCreateInfoNV
VkRayTracingPipelineInterfaceCreateInfoKHR
VkRayTracingShaderGroupCreateInfoKHR
VkRayTracingShaderGroupCreateInfoNV
VkRayTracingShaderGroupTypeKHR
VkRayTracingShaderGroupTypeNV
VkRect2D
VkRectLayerKHR
VkRefreshCycleDurationGOOGLE
vkRegisterDeviceEventEXT
vkRegisterDisplayEventEXT
vkReleaseDisplayEXT
vkReleaseFullScreenExclusiveModeEXT
vkReleasePerformanceConfigurationINTEL
vkReleaseProfilingLockKHR
VkRenderingAttachmentInfo
VkRenderingAttachmentInfoKHR
VkRenderingFlagBits
VkRenderingFlagBitsKHR
VkRenderingFlags
VkRenderingFlagsKHR
VkRenderingFragmentDensityMapAttachmentInfoEXT
VkRenderingFragmentShadingRateAttachmentInfoKHR
VkRenderingInfo
VkRenderingInfoKHR
VkRenderPass
VkRenderPassAttachmentBeginInfo
VkRenderPassAttachmentBeginInfoKHR
VkRenderPassBeginInfo
VkRenderPassCreateFlagBits
VkRenderPassCreateFlags
VkRenderPassCreateInfo2
VkRenderPassCreateInfo2KHR
VkRenderPassFragmentDensityMapCreateInfoEXT
VkRenderPassInputAttachmentAspectCreateInfo
VkRenderPassInputAttachmentAspectCreateInfoKHR
VkRenderPassMultiviewCreateInfo
VkRenderPassMultiviewCreateInfoKHR
VkRenderPassSampleLocationsBeginInfoEXT
VkRenderPassTransformBeginInfoQCOM
vkResetCommandBuffer
vkResetCommandPool
vkResetDescriptorPool
vkResetEvent
vkResetFences
vkResetQueryPool
vkResetQueryPoolEXT
VkResolveImageInfo2
VkResolveImageInfo2KHR
VkResolveModeFlagBits
VkResolveModeFlagBitsKHR
VkResolveModeFlags
VkResolveModeFlagsKHR
VkSampleCountFlagBits
VkSampleCountFlags
VkSampleLocationEXT
VkSampleLocationsInfoEXT
VkSampleMask
VkSampler
VkSamplerAddressMode
VkSamplerBorderColorComponentMappingCreateInfoEXT
VkSamplerCreateFlagBits
VkSamplerCreateFlags
VkSamplerCreateInfo
VkSamplerCustomBorderColorCreateInfoEXT
VkSamplerMipmapMode
VkSamplerReductionMode
VkSamplerReductionModeCreateInfo
VkSamplerReductionModeCreateInfoEXT
VkSamplerReductionModeEXT
VkSamplerYcbcrConversion
VkSamplerYcbcrConversionCreateInfo
VkSamplerYcbcrConversionCreateInfoKHR
VkSamplerYcbcrConversionImageFormatProperties
VkSamplerYcbcrConversionImageFormatPropertiesKHR
VkSamplerYcbcrConversionInfo
VkSamplerYcbcrConversionInfoKHR
VkSamplerYcbcrConversionKHR
VkSamplerYcbcrModelConversion
VkSamplerYcbcrModelConversionKHR
VkSamplerYcbcrRange
VkSamplerYcbcrRangeKHR
VkScopeNV
VkScreenSurfaceCreateFlagsQNX
VkScreenSurfaceCreateInfoQNX
VkSemaphore
VkSemaphoreCreateFlags
VkSemaphoreCreateInfo
VkSemaphoreGetFdInfoKHR
VkSemaphoreGetWin32HandleInfoKHR
VkSemaphoreGetZirconHandleInfoFUCHSIA
VkSemaphoreImportFlagBits
VkSemaphoreImportFlagBitsKHR
VkSemaphoreImportFlags
VkSemaphoreImportFlagsKHR
VkSemaphoreSignalInfo
VkSemaphoreSignalInfoKHR
VkSemaphoreSubmitInfo
VkSemaphoreSubmitInfoKHR
VkSemaphoreType
VkSemaphoreTypeCreateInfo
VkSemaphoreTypeCreateInfoKHR
VkSemaphoreTypeKHR
VkSemaphoreWaitFlagBits
VkSemaphoreWaitFlagBitsKHR
VkSemaphoreWaitFlags
VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitInfo
VkSemaphoreWaitInfoKHR
vkSetBufferCollectionBufferConstraintsFUCHSIA
vkSetBufferCollectionImageConstraintsFUCHSIA
vkSetDebugUtilsObjectNameEXT
vkSetDebugUtilsObjectTagEXT
vkSetDeviceMemoryPriorityEXT
vkSetEvent
vkSetHdrMetadataEXT
vkSetLocalDimmingAMD
vkSetPrivateData
vkSetPrivateDataEXT
VkSetStateFlagsIndirectCommandNV
VkShaderCorePropertiesFlagBitsAMD
VkShaderCorePropertiesFlagsAMD
VkShaderFloatControlsIndependence
VkShaderFloatControlsIndependenceKHR
VkShaderGroupShaderKHR
VkShaderInfoTypeAMD
VkShaderModule
VkShaderModuleCreateFlags
VkShaderModuleCreateInfo
VkShaderModuleValidationCacheCreateInfoEXT
VkShaderResourceUsageAMD
VkShaderStageFlagBits
VkShaderStageFlags
VkShaderStatisticsInfoAMD
VkShadingRatePaletteEntryNV
VkShadingRatePaletteNV
VkSharedPresentSurfaceCapabilitiesKHR
VkSharingMode
vkSignalSemaphore
vkSignalSemaphoreKHR
VkSparseBufferMemoryBindInfo
VkSparseImageFormatFlagBits
VkSparseImageFormatFlags
VkSparseImageFormatProperties
VkSparseImageFormatProperties2
VkSparseImageFormatProperties2KHR
VkSparseImageMemoryBind
VkSparseImageMemoryBindInfo
VkSparseImageMemoryRequirements
VkSparseImageMemoryRequirements2
VkSparseImageMemoryRequirements2KHR
VkSparseImageOpaqueMemoryBindInfo
VkSparseMemoryBind
VkSparseMemoryBindFlagBits
VkSparseMemoryBindFlags
VkSpecializationInfo
VkSpecializationMapEntry
VkSRTDataNV
VkStencilFaceFlagBits
VkStencilFaceFlags
VkStencilOp
VkStencilOpState
VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateInfoGGP
VkStridedDeviceAddressRegionKHR
VkStructureType
VkSubgroupFeatureFlagBits
VkSubgroupFeatureFlags
vkSubmitDebugUtilsMessageEXT
VkSubmitFlagBits
VkSubmitFlagBitsKHR
VkSubmitFlags
VkSubmitFlagsKHR
VkSubmitInfo
VkSubmitInfo2
VkSubmitInfo2KHR
VkSubpassBeginInfo
VkSubpassBeginInfoKHR
VkSubpassContents
VkSubpassDependency
VkSubpassDependency2
VkSubpassDependency2KHR
VkSubpassDescription2
VkSubpassDescription2KHR
VkSubpassDescriptionDepthStencilResolve
VkSubpassDescriptionDepthStencilResolveKHR
VkSubpassDescriptionFlagBits
VkSubpassDescriptionFlags
VkSubpassEndInfo
VkSubpassEndInfoKHR
VkSubpassFragmentDensityMapOffsetEndInfoQCOM
VkSubpassSampleLocationsEXT
VkSubpassShadingPipelineCreateInfoHUAWEI
VkSubresourceLayout
VkSurfaceCapabilities2EXT
VkSurfaceCapabilities2KHR
VkSurfaceCapabilitiesFullScreenExclusiveEXT
VkSurfaceCounterFlagBitsEXT
VkSurfaceCounterFlagsEXT
VkSurfaceFormat2KHR
VkSurfaceFullScreenExclusiveInfoEXT
VkSurfaceFullScreenExclusiveWin32InfoEXT
VkSurfaceProtectedCapabilitiesKHR
VkSurfaceTransformFlagBitsKHR
VkSurfaceTransformFlagsKHR
VkSwapchainCounterCreateInfoEXT
VkSwapchainCreateFlagBitsKHR
VkSwapchainCreateFlagsKHR
VkSwapchainDisplayNativeHdrCreateInfoAMD
VkSwapchainKHR
VkSysmemColorSpaceFUCHSIA
VkSystemAllocationScope
VkTessellationDomainOrigin
VkTessellationDomainOriginKHR
VkTextureLODGatherFormatPropertiesAMD
VkTimeDomainEXT
VkTimelineSemaphoreSubmitInfo
VkTimelineSemaphoreSubmitInfoKHR
VkToolPurposeFlagBits
VkToolPurposeFlagBitsEXT
VkToolPurposeFlags
VkToolPurposeFlagsEXT
VkTraceRaysIndirectCommandKHR
VkTransformMatrixKHR
VkTransformMatrixNV
vkTrimCommandPool
vkTrimCommandPoolKHR
vkUninitializePerformanceApiINTEL
vkUnmapMemory
vkUpdateDescriptorSets
vkUpdateDescriptorSetWithTemplate
vkUpdateDescriptorSetWithTemplateKHR
vkUpdateVideoSessionParametersKHR
VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateInfoEXT
VkValidationCacheEXT
VkValidationCacheHeaderVersionEXT
VkValidationCheckEXT
VkValidationFeatureDisableEXT
VkValidationFeatureEnableEXT
VkValidationFeaturesEXT
VkValidationFlagsEXT
VkVendorId
VkVertexInputAttributeDescription2EXT
VkVertexInputBindingDescription
VkVertexInputBindingDescription2EXT
VkVertexInputBindingDivisorDescriptionEXT
VkVertexInputRate
VkVideoBeginCodingFlagsKHR
VkVideoBeginCodingInfoKHR
VkVideoBindMemoryKHR
VkVideoCapabilitiesKHR
VkVideoCapabilityFlagBitsKHR
VkVideoCapabilityFlagsKHR
VkVideoChromaSubsamplingFlagBitsKHR
VkVideoChromaSubsamplingFlagsKHR
VkVideoCodecOperationFlagBitsKHR
VkVideoCodecOperationFlagsKHR
VkVideoCodingControlFlagBitsKHR
VkVideoCodingControlFlagsKHR
VkVideoCodingControlInfoKHR
VkVideoCodingQualityPresetFlagBitsKHR
VkVideoCodingQualityPresetFlagsKHR
VkVideoComponentBitDepthFlagBitsKHR
VkVideoComponentBitDepthFlagsKHR
VkVideoDecodeCapabilitiesKHR
VkVideoDecodeCapabilityFlagBitsKHR
VkVideoDecodeCapabilityFlagsKHR
VkVideoDecodeFlagBitsKHR
VkVideoDecodeFlagsKHR
VkVideoDecodeH264CapabilitiesEXT
VkVideoDecodeH264CreateFlagsEXT
VkVideoDecodeH264DpbSlotInfoEXT
VkVideoDecodeH264MvcEXT
VkVideoDecodeH264PictureInfoEXT
VkVideoDecodeH264PictureLayoutFlagBitsEXT
VkVideoDecodeH264PictureLayoutFlagsEXT
VkVideoDecodeH264ProfileEXT
VkVideoDecodeH264SessionCreateInfoEXT
VkVideoDecodeH264SessionParametersAddInfoEXT
VkVideoDecodeH264SessionParametersCreateInfoEXT
VkVideoDecodeH265CapabilitiesEXT
VkVideoDecodeH265CreateFlagsEXT
VkVideoDecodeH265DpbSlotInfoEXT
VkVideoDecodeH265PictureInfoEXT
VkVideoDecodeH265ProfileEXT
VkVideoDecodeH265SessionCreateInfoEXT
VkVideoDecodeH265SessionParametersAddInfoEXT
VkVideoDecodeH265SessionParametersCreateInfoEXT
VkVideoDecodeInfoKHR
VkVideoEncodeCapabilitiesKHR
VkVideoEncodeCapabilityFlagBitsKHR
VkVideoEncodeCapabilityFlagsKHR
VkVideoEncodeFlagBitsKHR
VkVideoEncodeFlagsKHR
VkVideoEncodeH264CapabilitiesEXT
VkVideoEncodeH264CapabilityFlagBitsEXT
VkVideoEncodeH264CapabilityFlagsEXT
VkVideoEncodeH264CreateFlagBitsEXT
VkVideoEncodeH264CreateFlagsEXT
VkVideoEncodeH264DpbSlotInfoEXT
VkVideoEncodeH264EmitPictureParametersEXT
VkVideoEncodeH264FrameSizeEXT
VkVideoEncodeH264InputModeFlagBitsEXT
VkVideoEncodeH264InputModeFlagsEXT
VkVideoEncodeH264NaluSliceEXT
VkVideoEncodeH264OutputModeFlagBitsEXT
VkVideoEncodeH264OutputModeFlagsEXT
VkVideoEncodeH264ProfileEXT
VkVideoEncodeH264QpEXT
VkVideoEncodeH264RateControlInfoEXT
VkVideoEncodeH264RateControlLayerInfoEXT
VkVideoEncodeH264RateControlStructureFlagBitsEXT
VkVideoEncodeH264ReferenceListsEXT
VkVideoEncodeH264SessionCreateInfoEXT
VkVideoEncodeH264SessionParametersAddInfoEXT
VkVideoEncodeH264SessionParametersCreateInfoEXT
VkVideoEncodeH264VclFrameInfoEXT
VkVideoEncodeH265CapabilitiesEXT
VkVideoEncodeH265CapabilityFlagBitsEXT
VkVideoEncodeH265CapabilityFlagsEXT
VkVideoEncodeH265CreateFlagsEXT
VkVideoEncodeH265CtbSizeFlagBitsEXT
VkVideoEncodeH265CtbSizeFlagsEXT
VkVideoEncodeH265DpbSlotInfoEXT
VkVideoEncodeH265EmitPictureParametersEXT
VkVideoEncodeH265FrameSizeEXT
VkVideoEncodeH265InputModeFlagBitsEXT
VkVideoEncodeH265InputModeFlagsEXT
VkVideoEncodeH265NaluSliceEXT
VkVideoEncodeH265NaluSliceSegmentEXT
VkVideoEncodeH265OutputModeFlagBitsEXT
VkVideoEncodeH265OutputModeFlagsEXT
VkVideoEncodeH265ProfileEXT
VkVideoEncodeH265QpEXT
VkVideoEncodeH265RateControlInfoEXT
VkVideoEncodeH265RateControlLayerInfoEXT
VkVideoEncodeH265RateControlStructureFlagBitsEXT
VkVideoEncodeH265ReferenceListsEXT
VkVideoEncodeH265SessionCreateInfoEXT
VkVideoEncodeH265SessionParametersAddInfoEXT
VkVideoEncodeH265SessionParametersCreateInfoEXT
VkVideoEncodeH265TransformBlockSizeFlagBitsEXT
VkVideoEncodeH265TransformBlockSizeFlagsEXT
VkVideoEncodeH265VclFrameInfoEXT
VkVideoEncodeInfoKHR
VkVideoEncodeRateControlFlagBitsKHR
VkVideoEncodeRateControlFlagsKHR
VkVideoEncodeRateControlInfoKHR
VkVideoEncodeRateControlLayerInfoKHR
VkVideoEncodeRateControlModeFlagBitsKHR
VkVideoEncodeRateControlModeFlagsKHR
VkVideoEndCodingFlagsKHR
VkVideoEndCodingInfoKHR
VkVideoFormatPropertiesKHR
VkVideoGetMemoryPropertiesKHR
VkVideoPictureResourceKHR
VkVideoProfileKHR
VkVideoProfilesKHR
VkVideoQueueFamilyProperties2KHR
VkVideoReferenceSlotKHR
VkVideoSessionCreateFlagBitsKHR
VkVideoSessionCreateFlagsKHR
VkVideoSessionCreateInfoKHR
VkVideoSessionKHR
VkVideoSessionParametersCreateInfoKHR
VkVideoSessionParametersKHR
VkVideoSessionParametersUpdateInfoKHR
VkViewport
VkViewportCoordinateSwizzleNV
VkViewportSwizzleNV
VkViewportWScalingNV
VkViSurfaceCreateFlagsNN
VkViSurfaceCreateInfoNN
vkWaitForFences
vkWaitForPresentKHR
vkWaitSemaphores
vkWaitSemaphoresKHR
VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateInfoKHR
VkWin32KeyedMutexAcquireReleaseInfoKHR
VkWin32KeyedMutexAcquireReleaseInfoNV
VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateInfoKHR
vkWriteAccelerationStructuresPropertiesKHR
VkWriteDescriptorSet
VkWriteDescriptorSetAccelerationStructureKHR
VkWriteDescriptorSetAccelerationStructureNV
VkWriteDescriptorSetInlineUniformBlock
VkWriteDescriptorSetInlineUniformBlockEXT
VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateInfoKHR
VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateInfoKHR
VkXYColorEXT
vkCreateXXX
vkAllocateXXX
vkDestroyXXX
vkFreeXXX

Vulkan Token

VkInstance
VkPhysicalDevice
VkDevice
VkPhysicalDeviceFeatures
VkQueue
VkSurfaceKHR
VkSwapchainKHR
VK_KHR_display
VK_KHR_display_swapchain
VkImageView
VkFramebuffer
VkPipeline
VkShaderModule
VkCommandBuffer
VkCommandPool
VkAllocationCallbacks
VkResult
VK_SUCCESS
VkApplicationInfo
VK_STRUCTURE_TYPE_APPLICATION_INFO
VK_MAKE_VERSION
VkApplicationInfo
VkInstanceCreateInfo
VK_ERROR_INITIALIZATION_FAILED
VK_LAYER_KHRONOS_validation
VkLayerProperties
VK_ERROR_LAYER_NOT_PRESENT
VK_NULL_HANDLE
VkPhysicalDeviceProperties
VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
VkQueueFamilyProperties
VK_QUEUE_GRAPHICS_BIT
VkDeviceQueueCreateInfo
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
VK_FALSE
VkDeviceCreateInfo
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
VK_KHR_swapchain
VK_KHR_surface
VK_KHR_win32_surface
VK_USE_PLATFORM_WIN32_KHR
VkWin32SurfaceCreateInfoKHR
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
VkBool32
VK_KHR_SWAPCHAIN_EXTENSION_NAME
VkExtensionProperties
VkSurfaceCapabilitiesKHR
VkSurfaceFormatKHR
VkPresentModeKHR
VK_FORMAT_B8G8R8A8_SRGB
VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
VK_COLORSPACE_SRGB_NONLINEAR_KHR
VK_PRESENT_MODE_IMMEDIATE_KHR
VK_PRESENT_MODE_FIFO_KHR
VK_PRESENT_MODE_FIFO_RELAXED_KHR
VK_PRESENT_MODE_MAILBOX_KHR
VkExtent2D
VkSwapchainCreateInfoKHR
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
VK_IMAGE_USAGE_TRANSFER_DST_BIT
VK_SHARING_MODE_CONCURRENT
VK_SHARING_MODE_EXCLUSIVE
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
VK_TRUE
VkImage
VkFormat
VkImageViewCreateInfo
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
VK_IMAGE_VIEW_TYPE_2D
VK_COMPONENT_SWIZZLE_IDENTITY
VK_IMAGE_ASPECT_COLOR_BIT
VkShaderModuleCreateInfo
VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
VkPipelineShaderStageCreateInfo
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
VK_SHADER_STAGE_VERTEX_BIT
VK_SHADER_STAGE_FRAGMENT_BIT
VkPipelineDynamicStateCreateInfo
VkDynamicState
VK_DYNAMIC_STATE_VIEWPORT
VK_DYNAMIC_STATE_SCISSOR
VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
VkPipelineVertexInputStateCreateInfo
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
VkPipelineInputAssemblyStateCreateInfo
VK_PRIMITIVE_TOPOLOGY_POINT_LIST
VK_PRIMITIVE_TOPOLOGY_LINE_LIST
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
VkViewport
VkRect2D
VkPipelineViewportStateCreateInfo
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
VkPipelineRasterizationStateCreateInfo
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
VK_POLYGON_MODE_FILL
VK_POLYGON_MODE_LINE
VK_POLYGON_MODE_POINT
VK_CULL_MODE_BACK_BIT
VK_FRONT_FACE_CLOCKWISE
VkPipelineMultisampleStateCreateInfo
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
VK_SAMPLE_COUNT_1_BIT
VkPipelineDepthStencilStateCreateInfo
VkPipelineColorBlendAttachmentState
VkPipelineColorBlendStateCreateInfo
VK_COLOR_COMPONENT_R_BIT
VK_COLOR_COMPONENT_G_BIT
VK_COLOR_COMPONENT_B_BIT
VK_COLOR_COMPONENT_A_BIT
VK_BLEND_FACTOR_ONE
VK_BLEND_FACTOR_ZERO
VK_BLEND_OP_ADD
VK_BLEND_FACTOR_SRC_ALPHA
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
VK_BLEND_FACTOR_ONE
VK_BLEND_FACTOR_ZERO
VkBlendFactor
VkBlendOp
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
VK_LOGIC_OP_COPY
VkPipelineLayout
VkPipelineLayoutCreateInfo
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
VkAttachmentDescription
VK_ATTACHMENT_LOAD_OP_CLEAR
VK_ATTACHMENT_STORE_OP_STORE
VK_ATTACHMENT_LOAD_OP_LOAD
VK_ATTACHMENT_LOAD_OP_DONT_CARE
VK_ATTACHMENT_STORE_OP_DONT_CARE
VK_IMAGE_LAYOUT_UNDEFINED
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
VkAttachmentReference
VkSubpassDescription
VK_PIPELINE_BIND_POINT_GRAPHICS
VkRenderPass
VkRenderPassCreateInfo
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
VkGraphicsPipelineCreateInfo
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
VK_PIPELINE_CREATE_DERIVATIVE_BIT
VkPipelineCache
VkFramebufferCreateInfo
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
VkCommandPoolCreateInfo
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
VkCommandBufferAllocateInfo
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
VK_COMMAND_BUFFER_LEVEL_PRIMARY
VK_COMMAND_BUFFER_LEVEL_SECONDARY
VkCommandBufferBeginInfo
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
VkRenderPassBeginInfo
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
VkClearValue
VK_SUBPASS_CONTENTS_INLINE
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
VK_PIPELINE_BIND_POINT_GRAPHICS
VkSemaphore
VkFence
VkSemaphoreCreateInfo
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
VkFenceCreateInfo
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
VK_FENCE_CREATE_SIGNALED_BIT
VkCommandBufferResetFlagBits
VkSubmitInfo
VK_STRUCTURE_TYPE_SUBMIT_INFO
VkPipelineStageFlags
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VkSubpassDependency
VK_SUBPASS_EXTERNAL
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
VkPresentInfoKHR
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
VK_ERROR_OUT_OF_DATE_KHR
VK_SUBOPTIMAL_KHR
VkVertexInputBindingDescription
VK_VERTEX_INPUT_RATE_VERTEX
VK_VERTEX_INPUT_RATE_INSTANCE
VkVertexInputAttributeDescription
VK_FORMAT_R32_SFLOAT
VK_FORMAT_R32G32_SFLOAT
VK_FORMAT_R32G32B32_SFLOAT
VK_FORMAT_R32G32B32A32_SFLOAT
VK_FORMAT_R32G32_SINT
VK_FORMAT_R32G32B32A32_UINT
VK_FORMAT_R64_SFLOAT
VkBufferCreateInfo
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
VkMemoryRequirements
VkMemoryPropertyFlags
VkPhysicalDeviceMemoryProperties
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VkMemoryAllocateInfo
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
VkMemoryType
VkDeviceMemory
VK_WHOLE_SIZE
VkDeviceSize
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
VK_QUEUE_TRANSFER_BIT
VK_BUFFER_USAGE_TRANSFER_SRC_BIT
VK_BUFFER_USAGE_TRANSFER_DST_BIT
VkBufferCopy
VK_BUFFER_USAGE_INDEX_BUFFER_BIT
VK_INDEX_TYPE_UINT16
VK_INDEX_TYPE_UINT32
VkDescriptorSetLayoutBinding
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
VkShaderStageFlagBits
VK_SHADER_STAGE_ALL_GRAPHICS
VkDescriptorSetLayout
VkDescriptorSetLayoutCreateInfo
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
VkDescriptorPoolSize
VkDescriptorPoolCreateInfo
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
VkDescriptorPool
VkDescriptorSetAllocateInfo
VkDescriptorSetLayout
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
VkDescriptorSet
VkDescriptorBufferInfo
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
VkImageCreateInfo
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
VK_IMAGE_TYPE_2D
VK_FORMAT_R8G8B8A8_SRGB
VK_IMAGE_TILING_OPTIMAL
VK_IMAGE_TILING_LINEAR
VK_IMAGE_LAYOUT_UNDEFINED
VK_IMAGE_LAYOUT_PREINITIALIZED
VK_IMAGE_USAGE_SAMPLED_BIT
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
VK_QUEUE_FAMILY_IGNORED
VK_IMAGE_ASPECT_COLOR_BIT
VK_ACCESS_UNIFORM_READ_BIT
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
VK_DEPENDENCY_BY_REGION_BIT
VkBufferImageCopy
VK_ACCESS_TRANSFER_WRITE_BIT
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
VK_PIPELINE_STAGE_TRANSFER_BIT
VK_ACCESS_SHADER_READ_BIT
VK_ACCESS_HOST_WRITE_BIT
VK_IMAGE_LAYOUT_GENERAL
VkImageTiling
VkImageUsageFlags
VkSamplerCreateInfo
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
VK_FILTER_LINEAR
VK_FILTER_NEAREST
VK_SAMPLER_ADDRESS_MODE_REPEAT
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER
VkPhysicalDeviceLimits
VK_BORDER_COLOR_INT_OPAQUE_BLACK
VK_COMPARE_OP_ALWAYS
VK_SAMPLER_MIPMAP_MODE_LINEAR
VkSampler
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
VK_SHADER_STAGE_FRAGMENT_BIT
VK_ERROR_POOL_OUT_OF_MEMORY
VK_LAYER_KHRONOS_validation
VkDescriptorImageInfo
VK_FORMAT_D32_SFLOAT
VK_FORMAT_D32_SFLOAT_S8_UINT
VK_FORMAT_D24_UNORM_S8_UINT
VkFormatFeatureFlags
VkFormatProperties
VK_IMAGE_TILING_LINEAR
VK_IMAGE_TILING_OPTIMAL
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
VkImageAspectFlags
VK_IMAGE_ASPECT_DEPTH_BIT
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
VK_IMAGE_ASPECT_STENCIL_BIT
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
VK_COMPARE_OP_LESS
VK_IMAGE_USAGE_TRANSFER_SRC_BIT
VK_ACCESS_TRANSFER_READ_BIT
VkImageBlit
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
VK_SAMPLER_MIPMAP_MODE_NEAREST
VK_SAMPLER_MIPMAP_MODE_LINEAR
VK_LOD_CLAMP_NONE
VkSampleCountFlagBits
VkSampleCountFlags
VK_SAMPLE_COUNT_64_BIT
VK_SAMPLE_COUNT_32_BIT
VK_SAMPLE_COUNT_16_BIT
VK_SAMPLE_COUNT_8_BIT
VK_SAMPLE_COUNT_4_BIT
VK_SAMPLE_COUNT_2_BIT
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VK_IMAGE_USAGE_STORAGE_BIT
VK_QUEUE_COMPUTE_BIT
VK_SHADER_STAGE_COMPUTE_BIT
VK_PIPELINE_BIND_POINT_COMPUTE
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
VkComputePipelineCreateInfo
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
VkAccessFlagBits2
VkAccessFlagBits2KHR
VkAccessFlags
VkAccessFlags2
VkAccessFlags2KHR
VK_AMD_buffer_marker
VK_AMD_device_coherent_memory
VK_AMD_display_native_hdr
VK_AMD_draw_indirect_count
VK_AMD_gcn_shader
VK_AMD_gpu_shader_half_float
VK_AMD_gpu_shader_int16
VK_AMD_memory_overallocation_behavior
VK_AMD_mixed_attachment_samples
VK_AMD_negative_viewport_height
VK_AMD_pipeline_compiler_control
VK_AMD_rasterization_order
VK_AMD_shader_ballot
VK_AMD_shader_core_properties
VK_AMD_shader_core_properties2
VK_AMD_shader_explicit_vertex_parameter
VK_AMD_shader_fragment_mask
VK_AMD_shader_image_load_store_lod
VK_AMD_shader_info
VK_AMD_shader_trinary_minmax
VK_AMD_texture_gather_bias_lod
VK_ANDROID_external_memory_android_hardware_buffer
VK_API_VERSION
VK_API_VERSION_1_0
VK_API_VERSION_1_1
VK_API_VERSION_1_2
VK_API_VERSION_1_3
VK_API_VERSION_MAJOR
VK_API_VERSION_MINOR
VK_API_VERSION_PATCH
VK_API_VERSION_VARIANT
VK_ARM_rasterization_order_attachment_access
VK_ATTACHMENT_UNUSED
VK_DEFINE_HANDLE
VK_DEFINE_NON_DISPATCHABLE_HANDLE
VK_EXT_4444_formats
VK_EXT_acquire_drm_display
VK_EXT_acquire_xlib_display
VK_EXT_astc_decode_mode
VK_EXT_blend_operation_advanced
VK_EXT_border_color_swizzle
VK_EXT_buffer_device_address
VK_EXT_calibrated_timestamps
VK_EXT_color_write_enable
VK_EXT_conditional_rendering
VK_EXT_conservative_rasterization
VK_EXT_custom_border_color
VK_EXT_debug_marker
VK_EXT_debug_report
VK_EXT_debug_utils
VK_EXT_depth_clip_control
VK_EXT_depth_clip_enable
VK_EXT_depth_range_unrestricted
VK_EXT_descriptor_indexing
VK_EXT_device_memory_report
VK_EXT_directfb_surface
VK_EXT_direct_mode_display
VK_EXT_discard_rectangles
VK_EXT_display_control
VK_EXT_display_surface_counter
VK_EXT_extended_dynamic_state
VK_EXT_extended_dynamic_state2
VK_EXT_external_memory_dma_buf
VK_EXT_external_memory_host
VK_EXT_filter_cubic
VK_EXT_fragment_density_map
VK_EXT_fragment_density_map2
VK_EXT_fragment_shader_interlock
VK_EXT_full_screen_exclusive
VK_EXT_global_priority
VK_EXT_global_priority_query
VK_EXT_graphics_pipeline_library
VK_EXT_hdr_metadata
VK_EXT_headless_surface
VK_EXT_host_query_reset
VK_EXT_image_2d_view_of_3d
VK_EXT_image_drm_format_modifier
VK_EXT_image_robustness
VK_EXT_image_view_min_lod
VK_EXT_index_type_uint8
VK_EXT_inline_uniform_block
VK_EXT_line_rasterization
VK_EXT_load_store_op_none
VK_EXT_memory_budget
VK_EXT_memory_priority
VK_EXT_metal_surface
VK_EXT_multi_draw
VK_EXT_pageable_device_local_memory
VK_EXT_pci_bus_info
VK_EXT_physical_device_drm
VK_EXT_pipeline_creation_cache_control
VK_EXT_pipeline_creation_feedback
VK_EXT_post_depth_coverage
VK_EXT_primitives_generated_query
VK_EXT_primitive_topology_list_restart
VK_EXT_private_data
VK_EXT_provoking_vertex
VK_EXT_queue_family_foreign
VK_EXT_rgba10x6_formats
VK_EXT_robustness2
VK_EXT_sampler_filter_minmax
VK_EXT_sample_locations
VK_EXT_scalar_block_layout
VK_EXT_separate_stencil_usage
VK_EXT_shader_atomic_float
VK_EXT_shader_atomic_float2
VK_EXT_shader_demote_to_helper_invocation
VK_EXT_shader_image_atomic_int64
VK_EXT_shader_stencil_export
VK_EXT_shader_subgroup_ballot
VK_EXT_shader_subgroup_vote
VK_EXT_shader_viewport_index_layer
VK_EXT_subgroup_size_control
VK_EXT_swapchain_colorspace
VK_EXT_texel_buffer_alignment
VK_EXT_texture_compression_astc_hdr
VK_EXT_tooling_info
VK_EXT_transform_feedback
VK_EXT_validation_cache
VK_EXT_validation_features
VK_EXT_validation_flags
VK_EXT_vertex_attribute_divisor
VK_EXT_vertex_input_dynamic_state
VK_EXT_video_decode_h264
VK_EXT_video_decode_h265
VK_EXT_video_encode_h264
VK_EXT_video_encode_h265
VK_EXT_ycbcr_2plane_444_formats
VK_EXT_ycbcr_image_arrays
VK_FALSE
VK_FUCHSIA_buffer_collection
VK_FUCHSIA_external_memory
VK_FUCHSIA_external_semaphore
VK_FUCHSIA_imagepipe_surface
VK_GGP_frame_token
VK_GGP_stream_descriptor_surface
VK_GOOGLE_decorate_string
VK_GOOGLE_display_timing
VK_GOOGLE_hlsl_functionality1
VK_GOOGLE_surfaceless_query
VK_GOOGLE_user_type
VK_HEADER_VERSION
VK_HEADER_VERSION_COMPLETE
VK_HUAWEI_invocation_mask
VK_HUAWEI_subpass_shading
VK_IMG_filter_cubic
VK_IMG_format_pvrtc
VK_INTEL_performance_query
VK_INTEL_shader_integer_functions2
VK_KHR_8bit_storage
VK_KHR_16bit_storage
VK_KHR_acceleration_structure
VK_KHR_android_surface
VK_KHR_bind_memory2
VK_KHR_buffer_device_address
VK_KHR_copy_commands2
VK_KHR_create_renderpass2
VK_KHR_dedicated_allocation
VK_KHR_deferred_host_operations
VK_KHR_depth_stencil_resolve
VK_KHR_descriptor_update_template
VK_KHR_device_group
VK_KHR_device_group_creation
VK_KHR_display
VK_KHR_display_swapchain
VK_KHR_draw_indirect_count
VK_KHR_driver_properties
VK_KHR_dynamic_rendering
VK_KHR_external_fence
VK_KHR_external_fence_capabilities
VK_KHR_external_fence_fd
VK_KHR_external_fence_win32
VK_KHR_external_memory
VK_KHR_external_memory_capabilities
VK_KHR_external_memory_fd
VK_KHR_external_memory_win32
VK_KHR_external_semaphore
VK_KHR_external_semaphore_capabilities
VK_KHR_external_semaphore_fd
VK_KHR_external_semaphore_win32
VK_KHR_format_feature_flags2
VK_KHR_fragment_shading_rate
VK_KHR_get_display_properties2
VK_KHR_get_memory_requirements2
VK_KHR_get_physical_device_properties2
VK_KHR_get_surface_capabilities2
VK_KHR_global_priority
VK_KHR_imageless_framebuffer
VK_KHR_image_format_list
VK_KHR_incremental_present
VK_KHR_maintenance1
VK_KHR_maintenance2
VK_KHR_maintenance3
VK_KHR_maintenance4
VK_KHR_multiview
VK_KHR_performance_query
VK_KHR_pipeline_executable_properties
VK_KHR_pipeline_library
VK_KHR_portability_enumeration
VK_KHR_portability_subset
VK_KHR_present_id
VK_KHR_present_wait
VK_KHR_push_descriptor
VK_KHR_ray_query
VK_KHR_ray_tracing_pipeline
VK_KHR_relaxed_block_layout
VK_KHR_sampler_mirror_clamp_to_edge
VK_KHR_sampler_ycbcr_conversion
VK_KHR_separate_depth_stencil_layouts
VK_KHR_shader_atomic_int64
VK_KHR_shader_clock
VK_KHR_shader_draw_parameters
VK_KHR_shader_float16_int8
VK_KHR_shader_float_controls
VK_KHR_shader_integer_dot_product
VK_KHR_shader_non_semantic_info
VK_KHR_shader_subgroup_extended_types
VK_KHR_shader_subgroup_uniform_control_flow
VK_KHR_shader_terminate_invocation
VK_KHR_shared_presentable_image
VK_KHR_spirv_1_4
VK_KHR_storage_buffer_storage_class
VK_KHR_surface
VK_KHR_surface_protected_capabilities
VK_KHR_swapchain_mutable_format
VK_KHR_synchronization2
VK_KHR_timeline_semaphore
VK_KHR_uniform_buffer_standard_layout
VK_KHR_variable_pointers
VK_KHR_video_decode_queue
VK_KHR_video_encode_queue
VK_KHR_video_queue
VK_KHR_vulkan_memory_model
VK_KHR_wayland_surface
VK_KHR_win32_keyed_mutex
VK_KHR_win32_surface
VK_KHR_workgroup_memory_explicit_layout
VK_KHR_xcb_surface
VK_KHR_xlib_surface
VK_KHR_zero_initialize_workgroup_memory
VK_LOD_CLAMP_NONE
VK_LUID_SIZE
VK_LUID_SIZE_KHR
VK_MAKE_API_VERSION
VK_MAKE_VERSION
VK_MAX_DESCRIPTION_SIZE
VK_MAX_DEVICE_GROUP_SIZE
VK_MAX_DEVICE_GROUP_SIZE_KHR
VK_MAX_DRIVER_INFO_SIZE
VK_MAX_DRIVER_INFO_SIZE_KHR
VK_MAX_DRIVER_NAME_SIZE
VK_MAX_DRIVER_NAME_SIZE_KHR
VK_MAX_EXTENSION_NAME_SIZE
VK_MAX_GLOBAL_PRIORITY_SIZE_EXT
VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
VK_MAX_MEMORY_HEAPS
VK_MAX_MEMORY_TYPES
VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
VK_MVK_ios_surface
VK_MVK_macos_surface
VK_NN_vi_surface
VK_NO_STDDEF_H
VK_NO_STDINT_H
VK_NVX_binary_import
VK_NVX_image_view_handle
VK_NVX_multiview_per_view_attributes
VK_NV_acquire_winrt_display
VK_NV_clip_space_w_scaling
VK_NV_compute_shader_derivatives
VK_NV_cooperative_matrix
VK_NV_corner_sampled_image
VK_NV_coverage_reduction_mode
VK_NV_dedicated_allocation
VK_NV_dedicated_allocation_image_aliasing
VK_NV_device_diagnostics_config
VK_NV_device_diagnostic_checkpoints
VK_NV_device_generated_commands
VK_NV_external_memory
VK_NV_external_memory_capabilities
VK_NV_external_memory_rdma
VK_NV_external_memory_win32
VK_NV_fill_rectangle
VK_NV_fragment_coverage_to_color
VK_NV_fragment_shader_barycentric
VK_NV_fragment_shading_rate_enums
VK_NV_framebuffer_mixed_samples
VK_NV_geometry_shader_passthrough
VK_NV_glsl_shader
VK_NV_inherited_viewport_scissor
VK_NV_linear_color_attachment
VK_NV_mesh_shader
VK_NV_ray_tracing
VK_NV_ray_tracing_motion_blur
VK_NV_representative_fragment_test
VK_NV_sample_mask_override_coverage
VK_NV_scissor_exclusive
VK_NV_shader_image_footprint
VK_NV_shader_sm_builtins
VK_NV_shader_subgroup_partitioned
VK_NV_shading_rate_image
VK_NV_viewport_array2
VK_NV_viewport_swizzle
VK_NV_win32_keyed_mutex
VK_QCOM_fragment_density_map_offset
VK_QCOM_render_pass_shader_resolve
VK_QCOM_render_pass_store_ops
VK_QCOM_render_pass_transform
VK_QCOM_rotated_copy_commands
VK_QNX_screen_surface
VK_QUEUE_FAMILY_EXTERNAL
VK_QUEUE_FAMILY_EXTERNAL_KHR
VK_QUEUE_FAMILY_FOREIGN_EXT
VK_QUEUE_FAMILY_IGNORED
VK_REMAINING_ARRAY_LAYERS
VK_REMAINING_MIP_LEVELS
VK_SHADER_UNUSED_KHR
VK_SHADER_UNUSED_NV
VK_SUBPASS_EXTERNAL
VK_TRUE
VK_USE_64_BIT_PTR_DEFINES
VK_UUID_SIZE
VK_VALVE_descriptor_set_host_mapping
VK_VALVE_mutable_descriptor_type
VK_VERSION_1_0
VK_VERSION_1_1
VK_VERSION_1_2
VK_VERSION_1_3
VK_VERSION_MAJOR
VK_VERSION_MINOR
VK_VERSION_PATCH
VK_WHOLE_SIZE

Other API

AHardwareBuffer
ANativeWindow
BaryCoordNoPerspAMD
BaryCoordNoPerspCentroidAMD
BaryCoordNoPerspNV
BaryCoordNoPerspSampleAMD
BaryCoordNV
BaryCoordPullModelAMD
BaryCoordSmoothAMD
BaryCoordSmoothCentroidAMD
BaryCoordSmoothSampleAMD
BaseInstance
BaseVertex
CAMetalLayer
ClipDistance
ClipDistancePerViewNV
CullDistance
CullDistancePerViewNV
CurrentRayTimeNV
DeviceIndex
DrawIndex
FragCoord
FragDepth
FragInvocationCountEXT
FragmentSizeNV
FragSizeEXT
FragStencilRefEXT
FrontFacing
FullyCoveredEXT
GlobalInvocationId
HelperInvocation
HitKindKHR
HitTNV
IncomingRayFlagsKHR
InstanceCustomIndexKHR
InstanceId
InstanceIndex
InvocationId
InvocationsPerPixelNV
LaunchIdKHR
LaunchSizeKHR
Layer
LayerPerViewNV
LocalInvocationId
LocalInvocationIndex
MeshViewCountNV
MeshViewIndicesNV
NumSubgroups
NumWorkgroups
ObjectRayDirectionKHR
ObjectRayOriginKHR
ObjectToWorldKHR
PatchVertices
PointCoord
PointSize
Position
PositionPerViewNV
PrimitiveCountNV
PrimitiveId
PrimitiveIndicesNV
PrimitiveShadingRateKHR
provisional-headers
RayGeometryIndexKHR
RayTmaxKHR
RayTminKHR
RuntimeSpirv
SampleId
SampleMask
SamplePosition
ShadingRateKHR
SMCountNV
SMIDNV
StandaloneSpirv
SubgroupEqMask
SubgroupGeMask
SubgroupGtMask
SubgroupId
SubgroupLeMask
SubgroupLocalInvocationId
SubgroupLtMask
SubgroupSize
TaskCountNV
TessCoord
TessLevelInner
TessLevelOuter
VertexIndex
ViewIndex
ViewportIndex
ViewportMaskNV
ViewportMaskPerViewNV
WarpIDNV
WarpsPerSMNV
WorkgroupId
WorkgroupSize
WorldRayDirectionKHR
WorldRayOriginKHR
WorldToObjectKHR
WSIheaders

		#include 

#include 
#include 
#include 
#include 
#include 

#define VK_USE_PLATFORM_WIN32_KHR
#define GLFW_INCLUDE_VULKAN
#include 
#define GLFW_EXPOSE_NATIVE_WIN32
#include 

#include  // Necessary for uint32_t
#include  // Necessary for std::numeric_limits
#include  // Necessary for std::clamp

#include 

#include 

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES//Unfortunately this method can break down if you start using nested structures.
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include 
#include 

#include 

#define STB_IMAGE_IMPLEMENTATION
#include 

#define TINYOBJLOADER_IMPLEMENTATION
#include 

#include 

#define GLM_ENABLE_EXPERIMENTAL
#include 

const uint32_t WIDTH = 800;
const uint32_t HEIGHT = 600;

const std::string MODEL_PATH = "models/viking_room.obj";
const std::string TEXTURE_PATH = "textures/viking_room.png";

const uint32_t PARTICLE_COUNT = 8192;

const int MAX_FRAMES_IN_FLIGHT = 2;

const std::vector validationLayers = {
    "VK_LAYER_KHRONOS_validation"
};

const std::vector deviceExtensions = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME
};

std::vector dynamicStates = {
    VK_DYNAMIC_STATE_VIEWPORT,
    VK_DYNAMIC_STATE_SCISSOR
};

#ifdef NDEBUG
    const bool enableValidationLayers = false;
#else
    const bool enableValidationLayers = true;
#endif

struct QueueFamilyIndices {
    std::optional graphicsAndComputeFamily ;
    std::optional presentFamily;

    bool isComplete() {
        return graphicsAndComputeFamily .has_value() && presentFamily.has_value();
    }
};

struct SwapChainSupportDetails {
    VkSurfaceCapabilitiesKHR capabilities;
    std::vector formats;
    std::vector presentModes;
};

struct UniformBufferObject {
    float deltaTime = 1.0f;
};

struct Particle {
    glm::vec2 position;
    glm::vec2 velocity;
    glm::vec4 color;

    static VkVertexInputBindingDescription getBindingDescription() {
        VkVertexInputBindingDescription bindingDescription{};
        bindingDescription.binding = 0;
        bindingDescription.stride = sizeof(Particle);
        bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;

        return bindingDescription;
    }

    static std::array getAttributeDescriptions() {
        std::array attributeDescriptions{};

        attributeDescriptions[0].binding = 0;
        attributeDescriptions[0].location = 0;
        attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
        attributeDescriptions[0].offset = offsetof(Particle, position);

        attributeDescriptions[1].binding = 0;
        attributeDescriptions[1].location = 1;
        attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
        attributeDescriptions[1].offset = offsetof(Particle, color);

        return attributeDescriptions;
    }
};

struct Vertex {
    glm::vec3 pos;
    glm::vec3 color;
    glm::vec2 texCoord;

    static VkVertexInputBindingDescription getBindingDescription() {
        VkVertexInputBindingDescription bindingDescription{};
		bindingDescription.binding = 0;
		bindingDescription.stride = sizeof(Vertex);
		bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;

        return bindingDescription;
    }

    static std::array getAttributeDescriptions() {
        std::array attributeDescriptions{};

        attributeDescriptions[0].binding = 0;
        attributeDescriptions[0].location = 0;
        attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
        attributeDescriptions[0].offset = offsetof(Vertex, pos);

        attributeDescriptions[1].binding = 0;
        attributeDescriptions[1].location = 1;
        attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
        attributeDescriptions[1].offset = offsetof(Vertex, color);

        attributeDescriptions[2].binding = 0;
        attributeDescriptions[2].location = 2;
        attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
        attributeDescriptions[2].offset = offsetof(Vertex, texCoord);

        return attributeDescriptions;
    }

    bool operator==(const Vertex& other) const {
	    return pos == other.pos && color == other.color && texCoord == other.texCoord;
	}
};

namespace std {
    template<> struct hash {
        size_t operator()(Vertex const& vertex) const {
            return ((hash()(vertex.pos) ^
                   (hash()(vertex.color) << 1)) >> 1) ^
                   (hash()(vertex.texCoord) << 1);
        }
    };
}

struct UniformBufferObject {
	alignas(16) glm::mat4 model;
    alignas(16) glm::mat4 view;
    alignas(16) glm::mat4 proj;
};

/*
const std::vector vertices = {
    {{-0.5f, -0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f}},
    {{0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}, {1.0f, 0.0f}},
    {{0.5f, 0.5f, 0.0f}, {0.0f, 0.0f, 1.0f}, {1.0f, 1.0f}},
    {{-0.5f, 0.5f, 0.0f}, {1.0f, 1.0f, 1.0f}, {0.0f, 1.0f}},

    {{-0.5f, -0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f}},
    {{0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}, {1.0f, 0.0f}},
    {{0.5f, 0.5f, -0.5f}, {0.0f, 0.0f, 1.0f}, {1.0f, 1.0f}},
    {{-0.5f, 0.5f, -0.5f}, {1.0f, 1.0f, 1.0f}, {0.0f, 1.0f}}
};

const std::vector indices = {
    0, 1, 2, 2, 3, 0,
    4, 5, 6, 6, 7, 4
};
*/

class HelloTriangleApplication {
public:
    void run() {
		initWindow();
        initVulkan();
        mainLoop();
        cleanup();
    }

private:
	VkInstance instance;

	VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
	VkSampleCountFlagBits msaaSamples = VK_SAMPLE_COUNT_1_BIT;
	VkDevice device;

	VkSurfaceKHR surface;

	VkQueue graphicsQueue;
	VkQueue computeQueue;
	VkQueue presentQueue;

	VkSwapchainKHR swapChain;

	std::vector swapChainImages;
	VkFormat swapChainImageFormat;
	VkExtent2D swapChainExtent;

	std::vector swapChainImageViews;

	std::vector swapChainFramebuffers;

	VkRenderPass renderPass;

	VkDescriptorSetLayout descriptorSetLayout;
	VkPipelineLayout pipelineLayout;
	VkPipeline graphicsPipeline;

    VkDescriptorSetLayout computeDescriptorSetLayout;
    VkPipelineLayout computePipelineLayout;
    VkPipeline computePipeline;

	VkCommandPool commandPool;

	VkImage colorImage;
	VkDeviceMemory colorImageMemory;
	VkImageView colorImageView;

	VkImage depthImage;
	VkDeviceMemory depthImageMemory;
	VkImageView depthImageView;


    uint32_t mipLevels;
    VkImage textureImage;
    VkDeviceMemory textureImageMemory;
    VkImageView textureImageView;
    VkSampler textureSampler;

	std::vector vertices;
	std::vector indices;
	VkBuffer vertexBuffer;
	VkDeviceMemory vertexBufferMemory;
	VkBuffer indexBuffer;
	VkDeviceMemory indexBufferMemory;

	std::vector uniformBuffers;
	std::vector uniformBuffersMemory;
	std::vector uniformBuffersMapped;

	VkDescriptorPool descriptorPool;

	std::vector descriptorSets;
    std::vector computeDescriptorSets;

	std::vector commandBuffers;
    std::vector computeCommandBuffers;

	std::vector imageAvailableSemaphores;
	std::vector renderFinishedSemaphores;
	std::vector inFlightFences;
	std::vector computeInFlightFences;
	std::vector computeFinishedSemaphores;

	uint32_t currentFrame = 0;

	bool framebufferResized = false;

	std::vector shaderStorageBuffers;
	std::vector shaderStorageBuffersMemory;

    double lastTime = 0.0f;
		
	void initWindow() {
		glfwInit();

		glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
		glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

		window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
		glfwSetWindowUserPointer(window, this);
		glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);

        lastTime = glfwGetTime();
	}

	static void framebufferResizeCallback(GLFWwindow* window, int width, int height) {
		auto app = reinterpret_cast(glfwGetWindowUserPointer(window));
    	app->framebufferResized = true;
	}

    void initVulkan() {
		createInstance();
    	createSurface();
		pickPhysicalDevice();
    	createLogicalDevice();
    	createSwapChain();
    	createImageViews();
    	createRenderPass();
    	createDescriptorSetLayout();
        createComputeDescriptorSetLayout();
    	createGraphicsPipeline();
        createComputePipeline();
    	loadModel();

    	createVertexBuffer();
    	createIndexBuffer();

    	createColorResources();
    	createDepthResources();
    	createFramebuffers();
    	createCommandPool();
    	createShaderStorageBuffers();
    	createUniformBuffers();
    	createDescriptorPool();
        createComputeDescriptorSets();

    	createTextureImage();
    	createTextureImageView();
    	createTextureSampler();
    	createDescriptorSets();

    	createCommandBuffer();
        createComputeCommandBuffers();
    	createSyncObjects();
    }

    void mainLoop() {
		while (!glfwWindowShouldClose(window)) {
			glfwPollEvents();
        	drawFrame();
        	// We want to animate the particle system using the last frames time to get smooth, frame-rate independent animation
            double currentTime = glfwGetTime();
            lastFrameTime = (currentTime - lastTime) * 1000.0;
            lastTime = currentTime;
		}

    	vkDeviceWaitIdle(device);
    }

    void cleanupSwapChain() {
	    vkDestroyImageView(device, colorImageView, nullptr);
	    vkDestroyImage(device, colorImage, nullptr);
	    vkFreeMemory(device, colorImageMemory, nullptr);

	    vkDestroyImageView(device, depthImageView, nullptr);
	    vkDestroyImage(device, depthImage, nullptr);
	    vkFreeMemory(device, depthImageMemory, nullptr);

		for (auto framebuffer : swapChainFramebuffers) {
	        vkDestroyFramebuffer(device, framebuffer, nullptr);
	    }

	    for (auto imageView : swapChainImageViews) {
	        vkDestroyImageView(device, imageView, nullptr);
	    }

	    //The images were created by the implementation for the swap chain and they will be automatically cleaned up once the swap chain has been destroyed, therefore we don’t need to add any cleanup code.
	    vkDestroySwapchainKHR(device, swapChain, nullptr);
	}

    void cleanup() {
    	cleanupSwapChain();

    	vkDestroySampler(device, textureSampler, nullptr);
    	vkDestroyImageView(device, textureImageView, nullptr);

	    vkDestroyImage(device, textureImage, nullptr);
	    vkFreeMemory(device, textureImageMemory, nullptr);

	    vkDestroyBuffer(device, indexBuffer, nullptr);
	    vkFreeMemory(device, indexBufferMemory, nullptr);

    	vkDestroyBuffer(device, vertexBuffer, nullptr);
    	vkFreeMemory(device, vertexBufferMemory, nullptr);

	    vkDestroyPipeline(device, graphicsPipeline, nullptr);
	    vkDestroyPipelineLayout(device, pipelineLayout, nullptr);

        vkDestroyPipeline(device, computePipeline, nullptr);
        vkDestroyPipelineLayout(device, computePipelineLayout, nullptr);

	    vkDestroyRenderPass(device, renderPass, nullptr);

	    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
	        vkDestroyBuffer(device, uniformBuffers[i], nullptr);
	        vkFreeMemory(device, uniformBuffersMemory[i], nullptr);
	    }

	    vkDestroyDescriptorPool(device, descriptorPool, nullptr);

	    vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);

        for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
            vkDestroyBuffer(device, shaderStorageBuffers[i], nullptr);
            vkFreeMemory(device, shaderStorageBuffersMemory[i], nullptr);
        }

	    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
	        vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
	        vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
	        vkDestroyFence(device, inFlightFences[i], nullptr);
            vkDestroySemaphore(device, computeFinishedSemaphores[i], nullptr);
            vkDestroyFence(device, computeInFlightFences[i], nullptr);
	    }

	    vkDestroyCommandPool(device, commandPool, nullptr);

	    vkDestroyDevice(device, nullptr);

	    vkDestroySurfaceKHR(instance, surface, nullptr);
	
		//VkPhysicalDevice will be implicitly destroyed when the VkInstance is destroyed
		vkDestroyInstance(instance, nullptr);
		
		glfwDestroyWindow(window);

		glfwTerminate();
    }

	void recreateSwapChain() {
		int width = 0, height = 0;
	    glfwGetFramebufferSize(window, &width, &height);
	    while (width == 0 || height == 0) {
	        glfwGetFramebufferSize(window, &width, &height);
	        glfwWaitEvents();
	    }

	    vkDeviceWaitIdle(device);

    	cleanupSwapChain();

	    createSwapChain();
	    createImageViews();
    	createColorResources();
    	createDepthResources();
	    createFramebuffers();
	}
	
	void createInstance() {
		if (enableValidationLayers && !checkValidationLayerSupport()) {
			throw std::runtime_error("validation layers requested, but not available!");
		}
		
		VkApplicationInfo appInfo{};
		appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
		appInfo.pApplicationName = "Hello Triangle";
		appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
		appInfo.pEngineName = "No Engine";
		appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
		appInfo.apiVersion = VK_API_VERSION_1_0;
		
		VkInstanceCreateInfo createInfo{};
		createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
		createInfo.pApplicationInfo = &appInfo;
		
		uint32_t glfwExtensionCount = 0;
		const char** glfwExtensions;
		glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
		createInfo.enabledExtensionCount = glfwExtensionCount;
		createInfo.ppEnabledExtensionNames = glfwExtensions;

		auto extensions = getRequiredExtensions();
        createInfo.enabledExtensionCount = static_cast(extensions.size());
        createInfo.ppEnabledExtensionNames = extensions.data();
		
		/*
		std::vector requiredExtensions;
		for(uint32_t i = 0; i < glfwExtensionCount; i++) {
			requiredExtensions.emplace_back(glfwExtensions[i]);
		}
		requiredExtensions.emplace_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
		createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
		createInfo.enabledExtensionCount = (uint32_t) requiredExtensions.size();
		createInfo.ppEnabledExtensionNames = requiredExtensions.data();
		*/
		
		if (enableValidationLayers) {
			createInfo.enabledLayerCount = static_cast(validationLayers.size());
			createInfo.ppEnabledLayerNames = validationLayers.data();
		} else {
			createInfo.enabledLayerCount = 0;
		}
		
		//kResult result = vkCreateInstance(&createInfo, nullptr, &instance);
		if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
			throw std::runtime_error("failed to create instance!");
		}
		
		uint32_t extensionCount = 0;
		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
		std::vector extensions(extensionCount);
		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
		std::cout << "available extensions:\n";
		for (const auto& extension : extensions) {
			std::cout << '\t' << extension.extensionName << '\n';
		}
	}

	void createSurface() {
		/*
		VkWin32SurfaceCreateInfoKHR createInfo{};
		createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
		createInfo.hwnd = glfwGetWin32Window(window);
		createInfo.hinstance = GetModuleHandle(nullptr);
		vkCreateWin32SurfaceKHR(instance, &createInfo, nullptr, &surface)
		*/
		if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
	        throw std::runtime_error("failed to create window surface!");
	    }
	}

	void pickPhysicalDevice() {
		uint32_t deviceCount = 0;
		vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);

		if (deviceCount == 0) {
		    throw std::runtime_error("failed to find GPUs with Vulkan support!");
		}

		std::vector devices(deviceCount);
		vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());

		for (const auto& device : devices) {
		    if (isDeviceSuitable(device)) {
		        physicalDevice = device;
            	msaaSamples = getMaxUsableSampleCount();
		        break;
		    }
		}

		if (physicalDevice == VK_NULL_HANDLE) {
		    throw std::runtime_error("failed to find a suitable GPU!");
		}

		/*
	    // Use an ordered map to automatically sort candidates by increasing score
	    std::multimap candidates;

	    for (const auto& device : devices) {
	        int score = rateDeviceSuitability(device);
	        candidates.insert(std::make_pair(score, device));
	    }

	    // Check if the best candidate is suitable at all
	    if (candidates.rbegin()->first > 0) {
	        physicalDevice = candidates.rbegin()->second;
	    } else {
	        throw std::runtime_error("failed to find a suitable GPU!");
	    }
	    */
	}

	void createLogicalDevice() {
		QueueFamilyIndices indices = findQueueFamilies(physicalDevice);

		std::vector queueCreateInfos;
		std::set uniqueQueueFamilies = {indices.graphicsAndComputeFamily .value(), indices.presentFamily.value()};

		float queuePriority = 1.0f;
		for (uint32_t queueFamily : uniqueQueueFamilies) {
		    VkDeviceQueueCreateInfo queueCreateInfo{};
		    queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
		    queueCreateInfo.queueFamilyIndex = queueFamily;
		    queueCreateInfo.queueCount = 1;
		    queueCreateInfo.pQueuePriorities = &queuePriority;
		    queueCreateInfos.push_back(queueCreateInfo);
		}

		VkPhysicalDeviceFeatures deviceFeatures{};
		deviceFeatures.samplerAnisotropy = VK_TRUE;
		deviceFeatures.sampleRateShading = VK_TRUE; // enable sample shading feature for the device

		VkDeviceCreateInfo createInfo{};
		createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

		createInfo.queueCreateInfoCount = static_cast(queueCreateInfos.size());
		createInfo.pQueueCreateInfos = queueCreateInfos.data();
		createInfo.pEnabledFeatures = &deviceFeatures;

		createInfo.enabledExtensionCount = static_cast(deviceExtensions.size());
		createInfo.ppEnabledExtensionNames = deviceExtensions.data();

		if (enableValidationLayers) {
		    createInfo.enabledLayerCount = static_cast(validationLayers.size());
		    createInfo.ppEnabledLayerNames = validationLayers.data();
		} else {
		    createInfo.enabledLayerCount = 0;
		}

		if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create logical device!");
		}

		vkGetDeviceQueue(device, indices.graphicsAndComputeFamily .value(), 0, &graphicsQueue);
		vkGetDeviceQueue(device, indices.graphicsAndComputeFamily .value(), 0, &computeQueue);
		vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
	}

	void createSwapChain() {
	    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);

	    VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
	    VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
	    VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);

	    uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;

	    if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {
		    imageCount = swapChainSupport.capabilities.maxImageCount;
		}

		VkSwapchainCreateInfoKHR createInfo{};
		createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
		createInfo.surface = surface;
		createInfo.minImageCount = imageCount;
		createInfo.imageFormat = surfaceFormat.format;
		createInfo.imageColorSpace = surfaceFormat.colorSpace;
		createInfo.imageExtent = extent;
		createInfo.imageArrayLayers = 1;
		createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;

		QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
		uint32_t queueFamilyIndices[] = {indices.graphicsAndComputeFamily .value(), indices.presentFamily.value()};

		if (indices.graphicsAndComputeFamily  != indices.presentFamily) {
		    createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
		    createInfo.queueFamilyIndexCount = 2;
		    createInfo.pQueueFamilyIndices = queueFamilyIndices;
		} else {
		    createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
		    createInfo.queueFamilyIndexCount = 0; // Optional
		    createInfo.pQueueFamilyIndices = nullptr; // Optional
		}

		createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
		createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
		createInfo.presentMode = presentMode;
		createInfo.clipped = VK_TRUE;
		createInfo.oldSwapchain = VK_NULL_HANDLE;

		if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create swap chain!");
		}

		vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
		swapChainImages.resize(imageCount);
		vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());

		swapChainImageFormat = surfaceFormat.format;
		swapChainExtent = extent;
	}

	void createImageViews() {
	    swapChainImageViews.resize(swapChainImages.size());

	    for (uint32_t i = 0; i < swapChainImages.size(); i++) {
	        swapChainImageViews[i] = createImageView(swapChainImages[i], swapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT, 1);
	    }
	}

	void createRenderPass() {
	    VkAttachmentDescription colorAttachment{};
	    colorAttachment.format = swapChainImageFormat;
	    colorAttachment.samples = msaaSamples;
	    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
		colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
		colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
		colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
		colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
		colorAttachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;//VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

		VkAttachmentDescription depthAttachment{};
		depthAttachment.format = findDepthFormat();
		depthAttachment.samples = msaaSamples;
		depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
		depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
		depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
		depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
		depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
		depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

		VkAttachmentDescription colorAttachmentResolve{};
	    colorAttachmentResolve.format = swapChainImageFormat;
	    colorAttachmentResolve.samples = VK_SAMPLE_COUNT_1_BIT;
	    colorAttachmentResolve.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	    colorAttachmentResolve.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
	    colorAttachmentResolve.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	    colorAttachmentResolve.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	    colorAttachmentResolve.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	    colorAttachmentResolve.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

		VkAttachmentReference colorAttachmentRef{};
		colorAttachmentRef.attachment = 0;
		colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

		VkAttachmentReference depthAttachmentRef{};
		depthAttachmentRef.attachment = 1;
		depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

		VkAttachmentReference colorAttachmentResolveRef{};
    	colorAttachmentResolveRef.attachment = 2;
    	colorAttachmentResolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

		VkSubpassDescription subpass{};
		subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
		subpass.colorAttachmentCount = 1;
		subpass.pColorAttachments = &colorAttachmentRef;
		subpass.pDepthStencilAttachment = &depthAttachmentRef;
	    subpass.pResolveAttachments = &colorAttachmentResolveRef;


		VkSubpassDependency dependency{};
		dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
		dependency.dstSubpass = 0;
		dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
	    dependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

		dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
		dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

	    std::array attachments = {colorAttachment, depthAttachment, colorAttachmentResolve};
		VkRenderPassCreateInfo renderPassInfo{};
		renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
		renderPassInfo.attachmentCount = static_cast(attachments.size());
		renderPassInfo.pAttachments = attachments.data();
		renderPassInfo.subpassCount = 1;
		renderPassInfo.pSubpasses = &subpass;
		renderPassInfo.dependencyCount = 1;
		renderPassInfo.pDependencies = &dependency;

		if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create render pass!");
		}
	}

	void createDescriptorSetLayout() {
	    VkDescriptorSetLayoutBinding uboLayoutBinding{};
	    uboLayoutBinding.binding = 0;
	    uboLayoutBinding.descriptorCount = 1;
	    uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
	    uboLayoutBinding.pImmutableSamplers = nullptr; // Optional
	    uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;

	    VkDescriptorSetLayoutBinding samplerLayoutBinding{};
		samplerLayoutBinding.binding = 1;
		samplerLayoutBinding.descriptorCount = 1;
		samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
		samplerLayoutBinding.pImmutableSamplers = nullptr;
		samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;

		std::array bindings = {uboLayoutBinding, samplerLayoutBinding};
		VkDescriptorSetLayoutCreateInfo layoutInfo{};
		layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
		layoutInfo.bindingCount = static_cast(bindings.size());
		layoutInfo.pBindings = bindings.data();

		if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create descriptor set layout!");
		}
	}

	void createComputeDescriptorSetLayout() {
        std::array layoutBindings{};
        layoutBindings[0].binding = 0;
        layoutBindings[0].descriptorCount = 1;
        layoutBindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
        layoutBindings[0].pImmutableSamplers = nullptr;
        //layoutBindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
        layoutBindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;

        layoutBindings[1].binding = 1;
        layoutBindings[1].descriptorCount = 1;
        layoutBindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
        layoutBindings[1].pImmutableSamplers = nullptr;
        layoutBindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;

        layoutBindings[2].binding = 2;
        layoutBindings[2].descriptorCount = 1;
        layoutBindings[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
        layoutBindings[2].pImmutableSamplers = nullptr;
        layoutBindings[2].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;

        VkDescriptorSetLayoutCreateInfo layoutInfo{};
        layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
        layoutInfo.bindingCount = 3;
        layoutInfo.pBindings = layoutBindings.data();

        if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &computeDescriptorSetLayout) != VK_SUCCESS) {
            throw std::runtime_error("failed to create compute descriptor set layout!");
        }
    }


	void createGraphicsPipeline() {
		auto vertShaderCode = readFile("shaders/vert.spv");
    	auto fragShaderCode = readFile("shaders/frag.spv");

    	//we’re allowed to destroy the shader modules again as soon as pipeline creation is finished,
    	VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
    	VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);

    	VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
		vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
		vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
		vertShaderStageInfo.module = vertShaderModule;
		vertShaderStageInfo.pName = "main";

		VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
		fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
		fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
		fragShaderStageInfo.module = fragShaderModule;
		fragShaderStageInfo.pName = "main";

		VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};

		VkPipelineDynamicStateCreateInfo dynamicState{};
		dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
		dynamicState.dynamicStateCount = static_cast(dynamicStates.size());
		dynamicState.pDynamicStates = dynamicStates.data();

		auto bindingDescription = Vertex::getBindingDescription();
		auto attributeDescriptions = Vertex::getAttributeDescriptions();

		VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
		vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
		vertexInputInfo.vertexBindingDescriptionCount = 1;
		vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
		vertexInputInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size());
		vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();

		VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
		inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
		inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
		inputAssembly.primitiveRestartEnable = VK_FALSE;

		VkViewport viewport{};
		viewport.x = 0.0f;
		viewport.y = 0.0f;
		viewport.width = (float) swapChainExtent.width;
		viewport.height = (float) swapChainExtent.height;
		viewport.minDepth = 0.0f;
		viewport.maxDepth = 1.0f;

		VkRect2D scissor{};
		scissor.offset = {0, 0};
		scissor.extent = swapChainExtent;

		VkPipelineViewportStateCreateInfo viewportState{};
		viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
		viewportState.viewportCount = 1;
		viewportState.scissorCount = 1;
		/*
		VkPipelineViewportStateCreateInfo viewportState{};
		viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
		viewportState.viewportCount = 1;
		viewportState.pViewports = &viewport;
		viewportState.scissorCount = 1;
		viewportState.pScissors = &scissor;
		*/

		//todo
		VkPipelineRasterizationStateCreateInfo rasterizer{};
		rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
		rasterizer.depthClampEnable = VK_FALSE;
		rasterizer.rasterizerDiscardEnable = VK_FALSE;
		rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
		rasterizer.lineWidth = 1.0f;
		rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
		rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
		rasterizer.depthBiasEnable = VK_FALSE;
		rasterizer.depthBiasConstantFactor = 0.0f; // Optional
		rasterizer.depthBiasClamp = 0.0f; // Optional
		rasterizer.depthBiasSlopeFactor = 0.0f; // Optional

		VkPipelineMultisampleStateCreateInfo multisampling{};
		multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
		multisampling.sampleShadingEnable = VK_FALSE;
		multisampling.rasterizationSamples = msaaSamples;
		multisampling.minSampleShading = 1.0f; // Optional
		multisampling.pSampleMask = nullptr; // Optional
		multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
		multisampling.alphaToOneEnable = VK_FALSE; // Optional
		multisampling.sampleShadingEnable = VK_TRUE; // enable sample shading in the pipeline
    	multisampling.minSampleShading = .2f; // min fraction for sample shading; closer to one is smoother


		VkPipelineColorBlendAttachmentState colorBlendAttachment{};
		colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
		colorBlendAttachment.blendEnable = VK_FALSE;
		colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
		colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
		colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
		colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
		colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
		colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional

		//todo
		VkPipelineColorBlendStateCreateInfo colorBlending{};
		colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
		colorBlending.logicOpEnable = VK_FALSE;
		colorBlending.logicOp = VK_LOGIC_OP_COPY; // Optional
		colorBlending.attachmentCount = 1;
		colorBlending.pAttachments = &colorBlendAttachment;
		colorBlending.blendConstants[0] = 0.0f; // Optional
		colorBlending.blendConstants[1] = 0.0f; // Optional
		colorBlending.blendConstants[2] = 0.0f; // Optional
		colorBlending.blendConstants[3] = 0.0f; // Optional

		//todo
		VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
		pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
		pipelineLayoutInfo.setLayoutCount = 1; // Optional
		pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout; // Optional
		pipelineLayoutInfo.pushConstantRangeCount = 0; // Optional
		pipelineLayoutInfo.pPushConstantRanges = nullptr; // Optional

		if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create pipeline layout!");
		}

		VkPipelineDepthStencilStateCreateInfo depthStencil{};
		depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
		depthStencil.depthTestEnable = VK_TRUE;
		depthStencil.depthWriteEnable = VK_TRUE;
		depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
		depthStencil.depthBoundsTestEnable = VK_FALSE;
		depthStencil.minDepthBounds = 0.0f; // Optional
		depthStencil.maxDepthBounds = 1.0f; // Optional
		depthStencil.stencilTestEnable = VK_FALSE;
		depthStencil.front = {}; // Optional
		depthStencil.back = {}; // Optional

		VkGraphicsPipelineCreateInfo pipelineInfo{};
		pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
		pipelineInfo.stageCount = 2;
		pipelineInfo.pStages = shaderStages;
		pipelineInfo.pVertexInputState = &vertexInputInfo;
		pipelineInfo.pInputAssemblyState = &inputAssembly;
		pipelineInfo.pViewportState = &viewportState;
		pipelineInfo.pRasterizationState = &rasterizer;
		pipelineInfo.pMultisampleState = &multisampling;
		pipelineInfo.pDepthStencilState = nullptr; // Optional
		pipelineInfo.pColorBlendState = &colorBlending;
		pipelineInfo.pDynamicState = &dynamicState;
		pipelineInfo.layout = pipelineLayout;
		pipelineInfo.renderPass = renderPass;
		pipelineInfo.subpass = 0;
		pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // Optional
		pipelineInfo.basePipelineIndex = -1; // Optional
		pipelineInfo.pDepthStencilState = &depthStencil;

		if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create graphics pipeline!");
		}

    	vkDestroyShaderModule(device, fragShaderModule, nullptr);
    	vkDestroyShaderModule(device, vertShaderModule, nullptr);
	}

	void createComputePipeline() {
        auto computeShaderCode = readFile("shaders/comp.spv");

        VkShaderModule computeShaderModule = createShaderModule(computeShaderCode);

        VkPipelineShaderStageCreateInfo computeShaderStageInfo{};
        computeShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        computeShaderStageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
        computeShaderStageInfo.module = computeShaderModule;
        computeShaderStageInfo.pName = "main";

        VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
        pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
        pipelineLayoutInfo.setLayoutCount = 1;
        pipelineLayoutInfo.pSetLayouts = &computeDescriptorSetLayout;

        if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &computePipelineLayout) != VK_SUCCESS) {
            throw std::runtime_error("failed to create compute pipeline layout!");
        }

        VkComputePipelineCreateInfo pipelineInfo{};
        pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
        pipelineInfo.layout = computePipelineLayout;
        pipelineInfo.stage = computeShaderStageInfo;

        if (vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &computePipeline) != VK_SUCCESS) {
            throw std::runtime_error("failed to create compute pipeline!");
        }

        vkDestroyShaderModule(device, computeShaderModule, nullptr);
    }

	void createFramebuffers() {
    	swapChainFramebuffers.resize(swapChainImageViews.size());

    	for (size_t i = 0; i < swapChainImageViews.size(); i++) {
		   std::array attachments = {
			    colorImageView,
	            depthImageView,
	            swapChainImageViews[i]
			};

			VkFramebufferCreateInfo framebufferInfo{};
			framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
			framebufferInfo.renderPass = renderPass;
			framebufferInfo.attachmentCount = static_cast(attachments.size());
			framebufferInfo.pAttachments = attachments.data();
			framebufferInfo.width = swapChainExtent.width;
			framebufferInfo.height = swapChainExtent.height;
			framebufferInfo.layers = 1;

		    if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) {
		        throw std::runtime_error("failed to create framebuffer!");
		    }
		}
	}

	void createCommandPool() {
		QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);

		VkCommandPoolCreateInfo poolInfo{};
		poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
		poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
		//Each command pool can only allocate command buffers that are submitted on a single type of queue. We’re going to record commands for drawing, which is why we’ve chosen the graphics queue family.
		poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsAndComputeFamily .value();

		if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create command pool!");
		}
	}

	void createShaderStorageBuffers() {

        // Initialize particles
        std::default_random_engine rndEngine((unsigned)time(nullptr));
        std::uniform_real_distribution rndDist(0.0f, 1.0f);

        // Initial particle positions on a circle
        std::vector particles(PARTICLE_COUNT);
        for (auto& particle : particles) {
            float r = 0.25f * sqrt(rndDist(rndEngine));
            float theta = rndDist(rndEngine) * 2.0f * 3.14159265358979323846f;
            float x = r * cos(theta) * HEIGHT / WIDTH;
            float y = r * sin(theta);
            particle.position = glm::vec2(x, y);
            particle.velocity = glm::normalize(glm::vec2(x,y)) * 0.00025f;
            particle.color = glm::vec4(rndDist(rndEngine), rndDist(rndEngine), rndDist(rndEngine), 1.0f);
        }

        VkDeviceSize bufferSize = sizeof(Particle) * PARTICLE_COUNT;

        // Create a staging buffer used to upload data to the gpu
        VkBuffer stagingBuffer;
        VkDeviceMemory stagingBufferMemory;
        createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);

        void* data;
        vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data);
        memcpy(data, particles.data(), (size_t)bufferSize);
        vkUnmapMemory(device, stagingBufferMemory);

        shaderStorageBuffers.resize(MAX_FRAMES_IN_FLIGHT);
        shaderStorageBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);

        // Copy initial particle data to all storage buffers
        for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
            createBuffer(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT/*storage buffer to stay in GPU memory only*/, shaderStorageBuffers[i], shaderStorageBuffersMemory[i]);
            copyBuffer(stagingBuffer, shaderStorageBuffers[i], bufferSize);
        }

        vkDestroyBuffer(device, stagingBuffer, nullptr);
        vkFreeMemory(device, stagingBufferMemory, nullptr);

    }

	void createColorResources() {
	    VkFormat colorFormat = swapChainImageFormat;

	    createImage(swapChainExtent.width, swapChainExtent.height, 1, msaaSamples, colorFormat, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, colorImage, colorImageMemory);
	    colorImageView = createImageView(colorImage, colorFormat, VK_IMAGE_ASPECT_COLOR_BIT, 1);
	}

	void createDepthResources() {
		VkFormat depthFormat = findDepthFormat();\
	    createImage(swapChainExtent.width, swapChainExtent.height, 1, msaaSamples, depthFormat, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, depthImage, depthImageMemory);

		depthImageView = createImageView(depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT, 1);

		transitionImageLayout(depthImage, depthFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 1);
	}

	VkFormat findSupportedFormat(const std::vector& candidates, VkImageTiling tiling, VkFormatFeatureFlags features) {
		for (VkFormat format : candidates) {
		    VkFormatProperties props;
		    vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);

		    if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) {
			    return format;
			} else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) {
			    return format;
			}
		}

    	throw std::runtime_error("failed to find supported format!");
	}

	VkFormat findDepthFormat() {
	    return findSupportedFormat(
	        {VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
	        VK_IMAGE_TILING_OPTIMAL,
	        VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
	    );
	}

	bool hasStencilComponent(VkFormat format) {
	    return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;
	}

	void createTextureImage() {
	    int texWidth, texHeight, texChannels;
	    stbi_uc* pixels = stbi_load(TEXTURE_PATH.c_str(), &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);
	    VkDeviceSize imageSize = texWidth * texHeight * 4;
	    mipLevels = static_cast(std::floor(std::log2(std::max(texWidth, texHeight)))) + 1;

	    if (!pixels) {
	        throw std::runtime_error("failed to load texture image!");
	    }

	    VkBuffer stagingBuffer;
		VkDeviceMemory stagingBufferMemory;

		createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);

		void* data;
		vkMapMemory(device, stagingBufferMemory, 0, imageSize, 0, &data);
	    	memcpy(data, pixels, static_cast(imageSize));
		vkUnmapMemory(device, stagingBufferMemory);

		stbi_image_free(pixels);

		createImage(texWidth, texHeight, mipLevels, VK_SAMPLE_COUNT_1_BIT, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, textureImage, textureImageMemory);

	    transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, mipLevels);

		copyBufferToImage(stagingBuffer, textureImage, static_cast(texWidth), static_cast(texHeight));

		//transitioned to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL while generating mipmaps
		//transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, mipLevels);

		generateMipmaps(textureImage, VK_FORMAT_R8G8B8A8_SRGB, texWidth, texHeight, mipLevels);


		vkDestroyBuffer(device, stagingBuffer, nullptr);
    	vkFreeMemory(device, stagingBufferMemory, nullptr);

	}

	void generateMipmaps(VkImage image, VkFormat imageFormat, int32_t texWidth, int32_t texHeight, uint32_t mipLevels) {
		// Check if image format supports linear blitting
	    VkFormatProperties formatProperties;
	    vkGetPhysicalDeviceFormatProperties(physicalDevice, imageFormat, &formatProperties);

	    if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
		    throw std::runtime_error("texture image format does not support linear blitting!");
		}

	    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

	    VkImageMemoryBarrier barrier{};
	    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
	    barrier.image = image;
	    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
	    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
	    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	    barrier.subresourceRange.baseArrayLayer = 0;
	    barrier.subresourceRange.layerCount = 1;
	    barrier.subresourceRange.levelCount = 1;

	    int32_t mipWidth = texWidth;
		int32_t mipHeight = texHeight;

		for (uint32_t i = 1; i < mipLevels; i++) {
			barrier.subresourceRange.baseMipLevel = i - 1;
			barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
			barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
			barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
			barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;

			vkCmdPipelineBarrier(commandBuffer,
			    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
			    0, nullptr,
			    0, nullptr,
			    1, &barrier);

			VkImageBlit blit{};
			blit.srcOffsets[0] = { 0, 0, 0 };
			blit.srcOffsets[1] = { mipWidth, mipHeight, 1 };
			blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			blit.srcSubresource.mipLevel = i - 1;
			blit.srcSubresource.baseArrayLayer = 0;
			blit.srcSubresource.layerCount = 1;
			blit.dstOffsets[0] = { 0, 0, 0 };
			blit.dstOffsets[1] = { mipWidth > 1 ? mipWidth / 2 : 1, mipHeight > 1 ? mipHeight / 2 : 1, 1 };
			blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			blit.dstSubresource.mipLevel = i;
			blit.dstSubresource.baseArrayLayer = 0;
			blit.dstSubresource.layerCount = 1;

			vkCmdBlitImage(commandBuffer,
		    image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
		    image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		    1, &blit,
		    VK_FILTER_LINEAR);

		    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
			barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
			barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
			barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

			vkCmdPipelineBarrier(commandBuffer,
			    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
			    0, nullptr,
			    0, nullptr,
			    1, &barrier);

			if (mipWidth > 1) mipWidth /= 2;
    		if (mipHeight > 1) mipHeight /= 2;
		}

		barrier.subresourceRange.baseMipLevel = mipLevels - 1;
	    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
	    barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
	    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
	    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

	    vkCmdPipelineBarrier(commandBuffer,
	        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
	        0, nullptr,
	        0, nullptr,
	        1, &barrier);

	    endSingleTimeCommands(commandBuffer);
	}

	VkSampleCountFlagBits getMaxUsableSampleCount() {
	    VkPhysicalDeviceProperties physicalDeviceProperties;
	    vkGetPhysicalDeviceProperties(physicalDevice, &physicalDeviceProperties);

	    VkSampleCountFlags counts = physicalDeviceProperties.limits.framebufferColorSampleCounts & physicalDeviceProperties.limits.framebufferDepthSampleCounts;
	    if (counts & VK_SAMPLE_COUNT_64_BIT) { return VK_SAMPLE_COUNT_64_BIT; }
	    if (counts & VK_SAMPLE_COUNT_32_BIT) { return VK_SAMPLE_COUNT_32_BIT; }
	    if (counts & VK_SAMPLE_COUNT_16_BIT) { return VK_SAMPLE_COUNT_16_BIT; }
	    if (counts & VK_SAMPLE_COUNT_8_BIT) { return VK_SAMPLE_COUNT_8_BIT; }
	    if (counts & VK_SAMPLE_COUNT_4_BIT) { return VK_SAMPLE_COUNT_4_BIT; }
	    if (counts & VK_SAMPLE_COUNT_2_BIT) { return VK_SAMPLE_COUNT_2_BIT; }

	    return VK_SAMPLE_COUNT_1_BIT;
	}

	void createTextureImageView() {
	    textureImageView = createImageView(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT, mipLevels);
	}

	void createTextureSampler() {
		VkSamplerCreateInfo samplerInfo{};
		samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
		samplerInfo.magFilter = VK_FILTER_LINEAR;
		samplerInfo.minFilter = VK_FILTER_LINEAR;
		samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
		samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
		samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
		//samplerInfo.anisotropyEnable = VK_FALSE;
		//samplerInfo.maxAnisotropy = 1.0f;
		samplerInfo.anisotropyEnable = VK_TRUE;

		VkPhysicalDeviceProperties properties{};
		vkGetPhysicalDeviceProperties(physicalDevice, &properties);
		samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;
		samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
		samplerInfo.unnormalizedCoordinates = VK_FALSE;
		//todo, PCF
		samplerInfo.compareEnable = VK_FALSE;
		samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
		samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
		samplerInfo.mipLodBias = 0.0f;
		//samplerInfo.minLod = static_cast(mipLevels / 2);
		samplerInfo.minLod = 0.0f;
		samplerInfo.maxLod = VK_LOD_CLAMP_NONE;

		if (vkCreateSampler(device, &samplerInfo, nullptr, &textureSampler) != VK_SUCCESS) {
	        throw std::runtime_error("failed to create texture sampler!");
	    }

	}

	VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags, uint32_t mipLevels) {
	    VkImageViewCreateInfo viewInfo{};
	    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
	    viewInfo.image = image;
	    viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
	    viewInfo.format = format;
	    viewInfo.subresourceRange.aspectMask = aspectFlags;
	    viewInfo.subresourceRange.baseMipLevel = 0;
	    viewInfo.subresourceRange.levelCount = mipLevels;
	    viewInfo.subresourceRange.baseArrayLayer = 0;
	    viewInfo.subresourceRange.layerCount = 1;

	    VkImageView imageView;
	    if (vkCreateImageView(device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) {
	        throw std::runtime_error("failed to create image view!");
	    }

	    return imageView;
	}

	void createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkSampleCountFlagBits numSamples, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) {
	    VkImageCreateInfo imageInfo{};
	    imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
	    imageInfo.imageType = VK_IMAGE_TYPE_2D;
	    imageInfo.extent.width = width;
	    imageInfo.extent.height = height;
	    imageInfo.extent.depth = 1;
        imageInfo.mipLevels = mipLevels;
	    imageInfo.arrayLayers = 1;
	    imageInfo.format = format;
	    imageInfo.tiling = tiling;
	    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	    imageInfo.usage = usage;
        imageInfo.samples = numSamples;
	    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
		imageInfo.flags = 0; // Optional//There are some optional flags for images that are related to sparse images. Sparse images are images where only certain regions are actually backed by memory.

	    if (vkCreateImage(device, &imageInfo, nullptr, &image) != VK_SUCCESS) {
	        throw std::runtime_error("failed to create image!");
	    }

	    VkMemoryRequirements memRequirements;
	    vkGetImageMemoryRequirements(device, image, &memRequirements);

	    VkMemoryAllocateInfo allocInfo{};
	    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	    allocInfo.allocationSize = memRequirements.size;
	    allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);

	    if (vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory) != VK_SUCCESS) {
	        throw std::runtime_error("failed to allocate image memory!");
	    }

	    vkBindImageMemory(device, image, imageMemory, 0);
	}

	void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, uint32_t mipLevels) {
	    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

	    VkImageMemoryBarrier barrier{};
		barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
		barrier.oldLayout = oldLayout;
		barrier.newLayout = newLayout;
		barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
		barrier.image = image;
		if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
		    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;

		    if (hasStencilComponent(format)) {
		        barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
		    }
		} else {
		    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		}
		barrier.subresourceRange.baseMipLevel = 0;
		barrier.subresourceRange.levelCount = mipLevels;
		barrier.subresourceRange.baseArrayLayer = 0;
		barrier.subresourceRange.layerCount = 1;

		VkPipelineStageFlags sourceStage;
		VkPipelineStageFlags destinationStage;

		if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
		    barrier.srcAccessMask = 0;
		    barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;

		    sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
		    destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
		} else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
		    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
		    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

		    sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
		    destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
		} else if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
		    barrier.srcAccessMask = 0;
		    barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

		    sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
		    destinationStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
		}else {
		    throw std::invalid_argument("unsupported layout transition!");
		}

		vkCmdPipelineBarrier(
		    commandBuffer,
		    sourceStage, destinationStage,
		    0,
		    0, nullptr,
		    0, nullptr,
		    1, &barrier
		);

	    endSingleTimeCommands(commandBuffer);
	}

	void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height) {
	    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

	    VkBufferImageCopy region{};
		region.bufferOffset = 0;
		region.bufferRowLength = 0;
		region.bufferImageHeight = 0;

		region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		region.imageSubresource.mipLevel = 0;
		region.imageSubresource.baseArrayLayer = 0;
		region.imageSubresource.layerCount = 1;

		region.imageOffset = {0, 0, 0};
		region.imageExtent = {
		    width,
		    height,
		    1
		};

		vkCmdCopyBufferToImage(
		    commandBuffer,
		    buffer,
		    image,
		    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		    1,
		    ®ion
		);

	    endSingleTimeCommands(commandBuffer);
	}

	void loadModel() {
	    tinyobj::attrib_t attrib;
	    std::vector shapes;
	    std::vector materials;
	    std::string warn, err;

	    if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, MODEL_PATH.c_str())) {
	        throw std::runtime_error(warn + err);
	    }

	    std::unordered_map uniqueVertices{};

	    for (const auto& shape : shapes) {
		    for (const auto& index : shape.mesh.indices) {
		        Vertex vertex{};

		        vertex.pos = {
				    attrib.vertices[3 * index.vertex_index + 0],
				    attrib.vertices[3 * index.vertex_index + 1],
				    attrib.vertices[3 * index.vertex_index + 2]
				};

				/*
				vertex.texCoord = {
				    attrib.texcoords[2 * index.texcoord_index + 0],
				    1.0f - attrib.texcoords[2 * index.texcoord_index + 1]
				};
				*/
				vertex.texCoord = {
				    attrib.texcoords[2 * index.texcoord_index + 0],
				    attrib.texcoords[2 * index.texcoord_index + 1]
				};

				vertex.color = {1.0f, 1.0f, 1.0f};

		        //vertices.push_back(vertex);
		        //indices.push_back(indices.size());
				if (uniqueVertices.count(vertex) == 0) {
		            uniqueVertices[vertex] = static_cast(vertices.size());
		            vertices.push_back(vertex);
		        }
        		indices.push_back(uniqueVertices[vertex]);
		    }
		}
	}

	void createVertexBuffer() {
	    VkDeviceSize bufferSize = sizeof(vertices[0]) * vertices.size();

	    VkBuffer stagingBuffer;
	    VkDeviceMemory stagingBufferMemory;
	    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);

		void* data;
		vkMapMemory(device, vertexBufferMemory, 0, bufferSize, 0, &data);
		memcpy(data, vertices.data(), (size_t) bufferSize);
		vkUnmapMemory(device, vertexBufferMemory);

		//The vertexBuffer is now allocated from a memory type that is device local, which generally means that we’re not able to use vkMapMemory
		createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vertexBuffer, vertexBufferMemory);

		copyBuffer(stagingBuffer, vertexBuffer, bufferSize);

	    vkDestroyBuffer(device, stagingBuffer, nullptr);
	    vkFreeMemory(device, stagingBufferMemory, nullptr);
	}

	void createIndexBuffer() {
	    VkDeviceSize bufferSize = sizeof(indices[0]) * indices.size();

	    VkBuffer stagingBuffer;
	    VkDeviceMemory stagingBufferMemory;
	    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);

	    void* data;
	    vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data);
	    memcpy(data, indices.data(), (size_t) bufferSize);
	    vkUnmapMemory(device, stagingBufferMemory);

	    createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, indexBuffer, indexBufferMemory);

	    copyBuffer(stagingBuffer, indexBuffer, bufferSize);

	    vkDestroyBuffer(device, stagingBuffer, nullptr);
	    vkFreeMemory(device, stagingBufferMemory, nullptr);
	}

	void createUniformBuffers() {
	    VkDeviceSize bufferSize = sizeof(UniformBufferObject);

	    uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT);
	    uniformBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);
	    uniformBuffersMapped.resize(MAX_FRAMES_IN_FLIGHT);

	    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
	        createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, uniformBuffers[i], uniformBuffersMemory[i]);

	        vkMapMemory(device, uniformBuffersMemory[i], 0, bufferSize, 0, &uniformBuffersMapped[i]);
	    }
	}

	void createDescriptorPool() {
		std::array poolSizes{};
		poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
		poolSizes[0].descriptorCount = static_cast(MAX_FRAMES_IN_FLIGHT);
		poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
		poolSizes[1].descriptorCount = static_cast(MAX_FRAMES_IN_FLIGHT);
		//poolSizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
		//poolSizes[1].descriptorCount = static_cast(MAX_FRAMES_IN_FLIGHT) * 2;

		VkDescriptorPoolCreateInfo poolInfo{};
		poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
		poolInfo.poolSizeCount = static_cast(poolSizes.size());
		poolInfo.pPoolSizes = poolSizes.data();
		poolInfo.maxSets = static_cast(MAX_FRAMES_IN_FLIGHT);

		if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create descriptor pool!");
		}
	}

	void createDescriptorSets() {
		std::vector layouts(MAX_FRAMES_IN_FLIGHT, descriptorSetLayout);
		VkDescriptorSetAllocateInfo allocInfo{};
		allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
		allocInfo.descriptorPool = descriptorPool;
		allocInfo.descriptorSetCount = static_cast(MAX_FRAMES_IN_FLIGHT);
		allocInfo.pSetLayouts = layouts.data();

		descriptorSets.resize(MAX_FRAMES_IN_FLIGHT);
		if (vkAllocateDescriptorSets(device, &allocInfo, descriptorSets.data()) != VK_SUCCESS) {
		    throw std::runtime_error("failed to allocate descriptor sets!");
		}

		for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
			VkDescriptorBufferInfo bufferInfo{};
		    bufferInfo.buffer = uniformBuffers[i];
		    bufferInfo.offset = 0;
		    bufferInfo.range = sizeof(UniformBufferObject);

		    VkDescriptorImageInfo imageInfo{};
		    imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
		    imageInfo.imageView = textureImageView;
		    imageInfo.sampler = textureSampler;


			std::array descriptorWrites{};

			descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
			descriptorWrites[0].dstSet = descriptorSets[i];
			descriptorWrites[0].dstBinding = 0;
			descriptorWrites[0].dstArrayElement = 0;
			descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
			descriptorWrites[0].descriptorCount = 1;
			descriptorWrites[0].pBufferInfo = &bufferInfo;

			descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
			descriptorWrites[1].dstSet = descriptorSets[i];
			descriptorWrites[1].dstBinding = 1;
			descriptorWrites[1].dstArrayElement = 0;
			descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
			descriptorWrites[1].descriptorCount = 1;
			descriptorWrites[1].pImageInfo = &imageInfo;

			vkUpdateDescriptorSets(device, static_cast(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
		}
	}

	void createComputeDescriptorSets() {
        std::vector layouts(MAX_FRAMES_IN_FLIGHT, computeDescriptorSetLayout);
        VkDescriptorSetAllocateInfo allocInfo{};
        allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
        allocInfo.descriptorPool = descriptorPool;
        allocInfo.descriptorSetCount = static_cast(MAX_FRAMES_IN_FLIGHT);
        allocInfo.pSetLayouts = layouts.data();

        computeDescriptorSets.resize(MAX_FRAMES_IN_FLIGHT);
        if (vkAllocateDescriptorSets(device, &allocInfo, computeDescriptorSets.data()) != VK_SUCCESS) {
            throw std::runtime_error("failed to allocate descriptor sets!");
        }

        for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
            VkDescriptorBufferInfo uniformBufferInfo{};
            uniformBufferInfo.buffer = uniformBuffers[i];
            uniformBufferInfo.offset = 0;
            uniformBufferInfo.range = sizeof(UniformBufferObject);

            std::array descriptorWrites{};
            descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
            descriptorWrites[0].dstSet = computeDescriptorSets[i];
            descriptorWrites[0].dstBinding = 0;
            descriptorWrites[0].dstArrayElement = 0;
            descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
            descriptorWrites[0].descriptorCount = 1;
            descriptorWrites[0].pBufferInfo = &uniformBufferInfo;

            VkDescriptorBufferInfo storageBufferInfoLastFrame{};
            storageBufferInfoLastFrame.buffer = shaderStorageBuffers[(i - 1) % MAX_FRAMES_IN_FLIGHT];
            storageBufferInfoLastFrame.offset = 0;
            storageBufferInfoLastFrame.range = sizeof(Particle) * PARTICLE_COUNT;

            descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
            descriptorWrites[1].dstSet = computeDescriptorSets[i];
            descriptorWrites[1].dstBinding = 1;
            descriptorWrites[1].dstArrayElement = 0;
            descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
            descriptorWrites[1].descriptorCount = 1;
            descriptorWrites[1].pBufferInfo = &storageBufferInfoLastFrame;

            VkDescriptorBufferInfo storageBufferInfoCurrentFrame{};
            storageBufferInfoCurrentFrame.buffer = shaderStorageBuffers[i];
            storageBufferInfoCurrentFrame.offset = 0;
            storageBufferInfoCurrentFrame.range = sizeof(Particle) * PARTICLE_COUNT;

            descriptorWrites[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
            descriptorWrites[2].dstSet = computeDescriptorSets[i];
            descriptorWrites[2].dstBinding = 2;
            descriptorWrites[2].dstArrayElement = 0;
            descriptorWrites[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
            descriptorWrites[2].descriptorCount = 1;
            descriptorWrites[2].pBufferInfo = &storageBufferInfoCurrentFrame;

            vkUpdateDescriptorSets(device, 3, descriptorWrites.data(), 0, nullptr);
        }
    }


	void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) {
	    VkBufferCreateInfo bufferInfo{};
	    bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
	    bufferInfo.size = size;
	    bufferInfo.usage = usage;
	    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

	    if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) {
	        throw std::runtime_error("failed to create buffer!");
	    }

	    VkMemoryRequirements memRequirements;
	    vkGetBufferMemoryRequirements(device, buffer, &memRequirements);

	    VkMemoryAllocateInfo allocInfo{};
	    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	    allocInfo.allocationSize = memRequirements.size;
	    allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);

	    if (vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS) {
	        throw std::runtime_error("failed to allocate buffer memory!");
	    }

	    vkBindBufferMemory(device, buffer, bufferMemory, 0);
	}

	VkCommandBuffer beginSingleTimeCommands() {
	    VkCommandBufferAllocateInfo allocInfo{};
	    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
	    allocInfo.commandPool = commandPool;
	    allocInfo.commandBufferCount = 1;

	    VkCommandBuffer commandBuffer;
	    vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);

	    VkCommandBufferBeginInfo beginInfo{};
	    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;

	    vkBeginCommandBuffer(commandBuffer, &beginInfo);

	    return commandBuffer;
	}

	void endSingleTimeCommands(VkCommandBuffer commandBuffer) {
	    vkEndCommandBuffer(commandBuffer);

	    VkSubmitInfo submitInfo{};
	    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	    submitInfo.commandBufferCount = 1;
	    submitInfo.pCommandBuffers = &commandBuffer;

	    vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
	    vkQueueWaitIdle(graphicsQueue);

	    vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
	}

	void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {
	    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

		VkBufferCopy copyRegion{};
		copyRegion.srcOffset = 0; // Optional
		copyRegion.dstOffset = 0; // Optional
		copyRegion.size = size;
		vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region);

		endSingleTimeCommands(commandBuffer);
	}

	uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) {
		VkPhysicalDeviceMemoryProperties memProperties;
		vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);

		for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
    		if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
		        return i;
		    }
		}

		throw std::runtime_error("failed to find suitable memory type!");
	}

	void createCommandBuffer() {
		commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);

		VkCommandBufferAllocateInfo allocInfo{};
		allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
		allocInfo.commandPool = commandPool;
		allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
		allocInfo.commandBufferCount =  (uint32_t) commandBuffers.size();

		if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
		    throw std::runtime_error("failed to allocate command buffers!");
		}
	}

    void createComputeCommandBuffers() {
        computeCommandBuffers.resize(MAX_FRAMES_IN_FLIGHT);

        VkCommandBufferAllocateInfo allocInfo{};
        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        allocInfo.commandPool = commandPool;
        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        allocInfo.commandBufferCount = (uint32_t)computeCommandBuffers.size();

        if (vkAllocateCommandBuffers(device, &allocInfo, computeCommandBuffers.data()) != VK_SUCCESS) {
            throw std::runtime_error("failed to allocate compute command buffers!");
        }
    }

	void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
		VkCommandBufferBeginInfo beginInfo{};
		beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
		beginInfo.flags = 0; // Optional
		beginInfo.pInheritanceInfo = nullptr; // Optional

		if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
		    throw std::runtime_error("failed to begin recording command buffer!");
		}

		VkRenderPassBeginInfo renderPassInfo{};
		renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
		renderPassInfo.renderPass = renderPass;
		renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];
		renderPassInfo.renderArea.offset = {0, 0};
		renderPassInfo.renderArea.extent = swapChainExtent;
		std::array clearValues{};
		clearValues[0].color = {{0.0f, 0.0f, 0.0f, 1.0f}};
		clearValues[1].depthStencil = {1.0f, 0};
		renderPassInfo.clearValueCount = static_cast(clearValues.size());
		renderPassInfo.pClearValues = clearValues.data();

		vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);

		vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);

		VkViewport viewport{};
		viewport.x = 0.0f;
		viewport.y = 0.0f;
		viewport.width = static_cast(swapChainExtent.width);
		viewport.height = static_cast(swapChainExtent.height);
		viewport.minDepth = 0.0f;
		viewport.maxDepth = 1.0f;
		vkCmdSetViewport(commandBuffer, 0, 1, &viewport);

		VkRect2D scissor{};
		scissor.offset = {0, 0};
		scissor.extent = swapChainExtent;
		vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
				
		VkBuffer vertexBuffers[] = {vertexBuffer};
		VkDeviceSize offsets[] = {0};
		vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);

		vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, /*VK_INDEX_TYPE_UINT16*/VK_INDEX_TYPE_UINT32);

		vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[currentFrame], 0, nullptr);

		//vkCmdDraw(commandBuffer, static_cast(vertices.size()), 1, 0, 0);
		vkCmdDrawIndexed(commandBuffer, static_cast(indices.size()), 1, 0, 0, 0);

		//vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
		//vkCmdDraw(commandBuffer, PARTICLE_COUNT, 1, 0, 0);
		vkCmdEndRenderPass(commandBuffer);

		if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
		    throw std::runtime_error("failed to record command buffer!");
		}
	}

	void recordComputeCommandBuffer(VkCommandBuffer commandBuffer) {
        VkCommandBufferBeginInfo beginInfo{};
        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

        if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
            throw std::runtime_error("failed to begin recording compute command buffer!");
        }

        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipeline);

        vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &computeDescriptorSets[currentFrame], 0, nullptr);

        vkCmdDispatch(commandBuffer, PARTICLE_COUNT / 256, 1, 1);

        if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
            throw std::runtime_error("failed to record compute command buffer!");
        }

    }

	void createSyncObjects() {
	    imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
	    renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
        computeFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
        inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
        computeInFlightFences.resize(MAX_FRAMES_IN_FLIGHT);


    	VkSemaphoreCreateInfo semaphoreInfo{};
    	semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
    	VkFenceCreateInfo fenceInfo{};
		fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
    	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;

	    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
	        if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
	            vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
	            vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) {

	            throw std::runtime_error("failed to create synchronization objects for a frame!");
	        }
            if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &computeFinishedSemaphores[i]) != VK_SUCCESS ||
                vkCreateFence(device, &fenceInfo, nullptr, &computeInFlightFences[i]) != VK_SUCCESS) {
                throw std::runtime_error("failed to create compute synchronization objects for a frame!");
            }

	    }
	}

	void updateUniformBuffer(uint32_t currentImage) {
	    static auto startTime = std::chrono::high_resolution_clock::now();

	    auto currentTime = std::chrono::high_resolution_clock::now();
	    float time = std::chrono::duration(currentTime - startTime).count();

	    UniformBufferObject ubo{};
		ubo.model = glm::rotate(glm::mat4(1.0f), time * glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f));

		ubo.view = glm::lookAt(glm::vec3(2.0f, 2.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));

		ubo.proj = glm::perspective(glm::radians(45.0f), swapChainExtent.width / (float) swapChainExtent.height, 0.1f, 10.0f);

		ubo.proj[1][1] *= -1;

		memcpy(uniformBuffersMapped[currentImage], &ubo, sizeof(ubo));

	}

	void drawFrame() {
        VkSubmitInfo submitInfo{};
        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

        // Compute submission        
        vkWaitForFences(device, 1, &computeInFlightFences[currentFrame], VK_TRUE, UINT64_MAX);

        updateUniformBuffer(currentFrame);

        vkResetFences(device, 1, &computeInFlightFences[currentFrame]);

        vkResetCommandBuffer(computeCommandBuffers[currentFrame], /*VkCommandBufferResetFlagBits*/ 0);
        recordComputeCommandBuffer(computeCommandBuffers[currentFrame]);

        submitInfo.commandBufferCount = 1;
        submitInfo.pCommandBuffers = &computeCommandBuffers[currentFrame];
        submitInfo.signalSemaphoreCount = 1;
        submitInfo.pSignalSemaphores = &computeFinishedSemaphores[currentFrame];

        if (vkQueueSubmit(computeQueue, 1, &submitInfo, computeInFlightFences[currentFrame]) != VK_SUCCESS) {
            throw std::runtime_error("failed to submit compute command buffer!");
        };


	    vkWaitForFences(device, 1, &inFlightFence[currentFrame], VK_TRUE, UINT64_MAX);

	    uint32_t imageIndex;
    	vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphore[currentFrame], VK_NULL_HANDLE, &imageIndex);

		if (result == VK_ERROR_OUT_OF_DATE_KHR) {
		    recreateSwapChain();
		    return;
		} else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
		    throw std::runtime_error("failed to acquire swap chain image!");
		}

	    vkResetFences(device, 1, &inFlightFence[currentFrame]);

    	vkResetCommandBuffer(commandBuffer[currentFrame], 0);

    	recordCommandBuffer(commandBuffer[currentFrame], imageIndex);

    	//Using a UBO this way is not the most efficient way to pass frequently changing values to the shader. A more efficient way to pass a small buffer of data to shaders are push constants
    	updateUniformBuffer(currentFrame);

    	VkSubmitInfo submitInfo{};
		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

        VkSemaphore waitSemaphores[] = { computeFinishedSemaphores[currentFrame], imageAvailableSemaphores[currentFrame] };
		VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
		submitInfo.waitSemaphoreCount = 2
		submitInfo.pWaitSemaphores = waitSemaphores;
		submitInfo.pWaitDstStageMask = waitStages;
		submitInfo.commandBufferCount = 1;
		submitInfo.pCommandBuffers = &commandBuffer[currentFrame];
		VkSemaphore signalSemaphores[] = {renderFinishedSemaphore[currentFrame]};
		submitInfo.signalSemaphoreCount = 1;
		submitInfo.pSignalSemaphores = signalSemaphores;

		if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFence[currentFrame]) != VK_SUCCESS) {
		    throw std::runtime_error("failed to submit draw command buffer!");
		}

		VkPresentInfoKHR presentInfo{};
		presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
		presentInfo.waitSemaphoreCount = 1;
		presentInfo.pWaitSemaphores = signalSemaphores;
		VkSwapchainKHR swapChains[] = {swapChain};
		presentInfo.swapchainCount = 1;
		presentInfo.pSwapchains = swapChains;
		presentInfo.pImageIndices = &imageIndex;
		presentInfo.pResults = nullptr; // Optional

		result = vkQueuePresentKHR(presentQueue, &presentInfo);

		if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || framebufferResized) {
		    framebufferResized = false;
		    recreateSwapChain();
		} else if (result != VK_SUCCESS) {
		    throw std::runtime_error("failed to present swap chain image!");
		}

		currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;

		currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
	}

	VkShaderModule createShaderModule(const std::vector& code) {
		VkShaderModuleCreateInfo createInfo{};
		createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
		createInfo.codeSize = code.size();
		//The buffer with the code can be freed immediately after creating the shader module.
		createInfo.pCode = reinterpret_cast(code.data());

		VkShaderModule shaderModule;
		if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
		    throw std::runtime_error("failed to create shader module!");
		}

        return shaderModule;
	}

	VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector& availableFormats) {
		for (const auto& availableFormat : availableFormats) {
		    if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
		        return availableFormat;
		    }
		}

    	return availableFormats[0];
	}

	VkPresentModeKHR chooseSwapPresentMode(const std::vector& availablePresentModes) {
	    for (const auto& availablePresentMode : availablePresentModes) {
	        if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
	            return availablePresentMode;
	        }
	    }

	    return VK_PRESENT_MODE_FIFO_KHR;
	}

	VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) {
	    if (capabilities.currentExtent.width != std::numeric_limits::max()) {
	        return capabilities.currentExtent;
	    } else {
	        int width, height;
	        glfwGetFramebufferSize(window, &width, &height);

	        VkExtent2D actualExtent = {
	            static_cast(width),
	            static_cast(height)
	        };

	        actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
	        actualExtent.height = std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);

	        return actualExtent;
	    }
	}

	SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
	    SwapChainSupportDetails details;

	    vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);

	    uint32_t formatCount;
		vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);

		if (formatCount != 0) {
		    details.formats.resize(formatCount);
		    vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
		}

		uint32_t presentModeCount;
		vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);

		if (presentModeCount != 0) {
		    details.presentModes.resize(presentModeCount);
		    vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
		}


	    return details;
	}

	bool isDeviceSuitable(VkPhysicalDevice device) {
		VkPhysicalDeviceProperties deviceProperties;
		vkGetPhysicalDeviceProperties(device, &deviceProperties);

		VkPhysicalDeviceFeatures deviceFeatures;
		vkGetPhysicalDeviceFeatures(device, &deviceFeatures);

	    QueueFamilyIndices indices = findQueueFamilies(device);

    	bool extensionsSupported = checkDeviceExtensionSupport(device);

    	bool swapChainAdequate = false;
		if (extensionsSupported) {
		    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
		    swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
		}

    	return indices.isComplete() && extensionsSupported && swapChainAdequate && deviceFeatures.samplerAnisotropy;

	    //return deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && deviceFeatures.geometryShader;
	}

	bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
	    uint32_t extensionCount;
	    vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);

	    std::vector availableExtensions(extensionCount);
	    vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());

	    std::set requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());

	    for (const auto& extension : availableExtensions) {
	        requiredExtensions.erase(extension.extensionName);
	    }

	    return requiredExtensions.empty();
	}

	QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
	    QueueFamilyIndices indices;

	    // Logic to find queue family indices to populate struct with
	    uint32_t queueFamilyCount = 0;
		vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
		std::vector queueFamilies(queueFamilyCount);
		vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());

		int i = 0;
		for (const auto& queueFamily : queueFamilies) {
	        if ((queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) && (queueFamily.queueFlags & VK_QUEUE_COMPUTE_BIT)) {

		        indices.graphicsAndComputeFamily  = i;
		    }

			VkBool32 presentSupport = false;
			vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
			if (presentSupport) {
			    indices.presentFamily = i;
			}

		    if (indices.isComplete()) {
		        break;
		    }

		    i++;
		}
	    
	    return indices;
	}

	std::vector getRequiredExtensions() {
        uint32_t glfwExtensionCount = 0;
        const char** glfwExtensions;
        glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

        std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);

        if (enableValidationLayers) {
            extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
        }

        return extensions;
    }

	bool checkValidationLayerSupport() {
		uint32_t layerCount;
		vkEnumerateInstanceLayerProperties(&layerCount, nullptr);

		std::vector availableLayers(layerCount);
		vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
		
		for (const char* layerName : validationLayers) {
			bool layerFound = false;

			for (const auto& layerProperties : availableLayers) {
				if (strcmp(layerName, layerProperties.layerName) == 0) {
					layerFound = true;
					break;
				}
			}

			if (!layerFound) {
				return false;
			}
		}

		return true;
	}

	static std::vector readFile(const std::string& filename) 
	{
	    std::ifstream file(filename, std::ios::ate | std::ios::binary);

	    if (!file.is_open()) {
	        throw std::runtime_error("failed to open file!");
	    }

	    size_t fileSize = (size_t) file.tellg();
		std::vector buffer(fileSize);

		file.seekg(0);
		file.read(buffer.data(), fileSize);

		file.close();

		return buffer;
	}

	int rateDeviceSuitability(VkPhysicalDevice device) {
	    int score = 0;

	    // Discrete GPUs have a significant performance advantage
	    if (deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
	        score += 1000;
	    }

	    // Maximum possible size of textures affects graphics quality
	    score += deviceProperties.limits.maxImageDimension2D;

	    // Application can't function without geometry shaders
	    if (!deviceFeatures.geometryShader) {
	        return 0;
	    }

	    return score;
	}
};

int main() {
    HelloTriangleApplication app;

    try {
        app.run();
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}
	
----------------------------------------------------------------------------------------	
VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkInstance* instance) {

	if (pCreateInfo == nullptr || instance == nullptr) {
		log("Null pointer passed to required parameter!");
		return VK_ERROR_INITIALIZATION_FAILED;
	}

	return real_vkCreateInstance(pCreateInfo, pAllocator, instance);
}

----------------------------------------------------------------------------------------
#version 450

//layout(set = 0, binding = 0) uniform UniformBufferObject { ... }
layout(binding = 0) uniform UniformBufferObject {
    mat4 model;
    mat4 view;
    mat4 proj;
} ubo;

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 2) in vec2 inTexCoord;
/*
layout(location = 0) in dvec3 inPosition;
layout(location = 2) in vec3 inColor;
*/

layout(location = 0) out vec3 fragColor;
layout(location = 1) out vec2 fragTexCoord;

void main() {
    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
    fragColor = inColor;
    fragTexCoord = inTexCoord;
}

----------------------------------------------------------------------------------------
#version 450

layout(binding = 1) uniform sampler2D texSampler;

layout(location = 0) in vec3 fragColor;
layout(location = 1) in vec2 fragTexCoord;

layout(location = 0) out vec4 outColor;

void main() {
	//outColor = texture(texSampler, fragTexCoord * 2.0);
    outColor = vec4(fragColor * texture(texSampler, fragTexCoord).rgb, 1.0);
}

----------------------------------------------------------------------------------------
#version 450

struct Particle {
    glm::vec2 position;
    glm::vec2 velocity;
    glm::vec4 color;

    static VkVertexInputBindingDescription getBindingDescription() {
        VkVertexInputBindingDescription bindingDescription{};
        bindingDescription.binding = 0;
        bindingDescription.stride = sizeof(Particle);
        bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;

        return bindingDescription;
    }

    static std::array getAttributeDescriptions() {
        std::array attributeDescriptions{};

        attributeDescriptions[0].binding = 0;
        attributeDescriptions[0].location = 0;
        attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
        attributeDescriptions[0].offset = offsetof(Particle, position);

        attributeDescriptions[1].binding = 0;
        attributeDescriptions[1].location = 1;
        attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
        attributeDescriptions[1].offset = offsetof(Particle, color);

        return attributeDescriptions;
    }
};

layout (binding = 0) uniform ParameterUBO {
    float deltaTime;
} ubo;

layout(std140, binding = 1) readonly buffer ParticleSSBOIn {
   Particle particlesIn[ ];
};

layout(std140, binding = 2) buffer ParticleSSBOOut {
   Particle particlesOut[ ];
};

layout (local_size_x = 256, local_size_y = 1, local_size_z = 1) in;

void main() 
{
    uint index = gl_GlobalInvocationID.x;  

    Particle particleIn = particlesIn[index];

    particlesOut[index].position = particleIn.position + particleIn.velocity.xy * ubo.deltaTime;
    particlesOut[index].velocity = particleIn.velocity;

    // Flip movement at window border
    if ((particlesOut[index].position.x <= -1.0) || (particlesOut[index].position.x >= 1.0)) {
        particlesOut[index].velocity.x = -particlesOut[index].velocity.x;
    }
    if ((particlesOut[index].position.y <= -1.0) || (particlesOut[index].position.y >= 1.0)) {
        particlesOut[index].velocity.y = -particlesOut[index].velocity.y;
    }

}

----------------------------------------------------------------------------------------
lod = getLodLevelFromScreenSize(); //smaller when the object is close, may be negative
lod = clamp(lod + mipLodBias, minLod, maxLod);

level = clamp(floor(lod), 0, texture.mipLevels - 1);  //clamped to the number of mip levels in the texture

if (mipmapMode == VK_SAMPLER_MIPMAP_MODE_NEAREST) {
    color = sample(level);
} else {
    color = blend(sample(level), sample(level + 1));
}

----------------------------------------------------------------------------------------
VkImageCreateInfo imageInfo {};
imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
if (vkCreateImage(device, &imageInfo, nullptr, &textureImage) != VK_SUCCESS) {
    throw std::runtime_error("failed to create image!");
}

layout (binding = 0, rgba8) uniform readonly image2D inputImage;
layout (binding = 1, rgba8) uniform writeonly image2D outputImage;

vec3 pixel = imageLoad(inputImage, ivec2(gl_GlobalInvocationID.xy)).rgb;
imageStore(outputImage, ivec2(gl_GlobalInvocationID.xy), pixel);