diff --git a/CMakeLists.txt b/CMakeLists.txt index 33358761c..9bcd36936 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -824,20 +824,22 @@ if(NOT (APPLE OR ANDROID OR USE_GLES OR USE_GLES2)) endif() if(USE_VULKAN AND NOT APPLE) - if(ANDROID) - set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_ANDROID_KHR) - elseif(X11_FOUND) - set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_XLIB_KHR) - elseif(WIN32) - set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_WIN32_KHR) - endif() + if(NOT LIBRETRO) + if(ANDROID) + set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_ANDROID_KHR) + elseif(X11_FOUND) + set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_XLIB_KHR) + elseif(WIN32) + set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_WIN32_KHR) + endif() + + set(VOLK_PULL_IN_VULKAN OFF) + add_subdirectory(core/deps/volk) + target_include_directories(volk PRIVATE core/khronos) + target_link_libraries(${PROJECT_NAME} PRIVATE volk) + endif() - set(VOLK_PULL_IN_VULKAN OFF) - add_subdirectory(core/deps/volk) - target_include_directories(volk PRIVATE core/khronos) - target_link_libraries(${PROJECT_NAME} PRIVATE volk) - - target_compile_definitions(${PROJECT_NAME} PRIVATE USE_VULKAN) + target_compile_definitions(${PROJECT_NAME} PRIVATE USE_VULKAN HAVE_VULKAN) target_sources(${PROJECT_NAME} PRIVATE core/rend/vulkan/oit/oit_buffer.h core/rend/vulkan/oit/oit_drawer.cpp @@ -870,12 +872,17 @@ if(USE_VULKAN AND NOT APPLE) core/rend/vulkan/vmallocator.h core/rend/vulkan/overlay.cpp core/rend/vulkan/overlay.h - core/rend/vulkan/vulkan_context.cpp core/rend/vulkan/vulkan_context.h core/rend/vulkan/vulkan.h core/rend/vulkan/vulkan_renderer.cpp) - if(NOT LIBRETRO) + if(LIBRETRO) target_sources(${PROJECT_NAME} PRIVATE + core/rend/vulkan/vk_context_lr.cpp + core/rend/vulkan/vk_context_lr.h + core/deps/libretro-common/vulkan/vulkan_symbol_wrapper.c) + else() + target_sources(${PROJECT_NAME} PRIVATE + core/rend/vulkan/vulkan_context.cpp core/rend/vulkan/imgui_impl_vulkan.cpp core/rend/vulkan/imgui_impl_vulkan.h) endif() diff --git a/core/deps/libretro-common/vulkan/vulkan_symbol_wrapper.c b/core/deps/libretro-common/vulkan/vulkan_symbol_wrapper.c new file mode 100644 index 000000000..3e2f271a2 --- /dev/null +++ b/core/deps/libretro-common/vulkan/vulkan_symbol_wrapper.c @@ -0,0 +1,811 @@ + +/* This header is autogenerated by vulkan_loader_generator.py */ +#include + +PFN_vkCreateInstance vulkan_symbol_wrapper_vkCreateInstance; +PFN_vkEnumerateInstanceExtensionProperties vulkan_symbol_wrapper_vkEnumerateInstanceExtensionProperties; +PFN_vkEnumerateInstanceLayerProperties vulkan_symbol_wrapper_vkEnumerateInstanceLayerProperties; +PFN_vkDestroyInstance vulkan_symbol_wrapper_vkDestroyInstance; +PFN_vkEnumeratePhysicalDevices vulkan_symbol_wrapper_vkEnumeratePhysicalDevices; +PFN_vkGetPhysicalDeviceFeatures vulkan_symbol_wrapper_vkGetPhysicalDeviceFeatures; +PFN_vkGetPhysicalDeviceFormatProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceFormatProperties; +PFN_vkGetPhysicalDeviceImageFormatProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceImageFormatProperties; +PFN_vkGetPhysicalDeviceProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceProperties; +PFN_vkGetPhysicalDeviceQueueFamilyProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceQueueFamilyProperties; +PFN_vkGetPhysicalDeviceMemoryProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceMemoryProperties; +PFN_vkGetDeviceProcAddr vulkan_symbol_wrapper_vkGetDeviceProcAddr; +PFN_vkCreateDevice vulkan_symbol_wrapper_vkCreateDevice; +PFN_vkDestroyDevice vulkan_symbol_wrapper_vkDestroyDevice; +PFN_vkEnumerateDeviceExtensionProperties vulkan_symbol_wrapper_vkEnumerateDeviceExtensionProperties; +PFN_vkEnumerateDeviceLayerProperties vulkan_symbol_wrapper_vkEnumerateDeviceLayerProperties; +PFN_vkGetDeviceQueue vulkan_symbol_wrapper_vkGetDeviceQueue; +PFN_vkQueueSubmit vulkan_symbol_wrapper_vkQueueSubmit; +PFN_vkQueueWaitIdle vulkan_symbol_wrapper_vkQueueWaitIdle; +PFN_vkDeviceWaitIdle vulkan_symbol_wrapper_vkDeviceWaitIdle; +PFN_vkAllocateMemory vulkan_symbol_wrapper_vkAllocateMemory; +PFN_vkFreeMemory vulkan_symbol_wrapper_vkFreeMemory; +PFN_vkMapMemory vulkan_symbol_wrapper_vkMapMemory; +PFN_vkUnmapMemory vulkan_symbol_wrapper_vkUnmapMemory; +PFN_vkFlushMappedMemoryRanges vulkan_symbol_wrapper_vkFlushMappedMemoryRanges; +PFN_vkInvalidateMappedMemoryRanges vulkan_symbol_wrapper_vkInvalidateMappedMemoryRanges; +PFN_vkGetDeviceMemoryCommitment vulkan_symbol_wrapper_vkGetDeviceMemoryCommitment; +PFN_vkBindBufferMemory vulkan_symbol_wrapper_vkBindBufferMemory; +PFN_vkBindImageMemory vulkan_symbol_wrapper_vkBindImageMemory; +PFN_vkGetBufferMemoryRequirements vulkan_symbol_wrapper_vkGetBufferMemoryRequirements; +PFN_vkGetImageMemoryRequirements vulkan_symbol_wrapper_vkGetImageMemoryRequirements; +PFN_vkGetImageSparseMemoryRequirements vulkan_symbol_wrapper_vkGetImageSparseMemoryRequirements; +PFN_vkGetPhysicalDeviceSparseImageFormatProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceSparseImageFormatProperties; +PFN_vkQueueBindSparse vulkan_symbol_wrapper_vkQueueBindSparse; +PFN_vkCreateFence vulkan_symbol_wrapper_vkCreateFence; +PFN_vkDestroyFence vulkan_symbol_wrapper_vkDestroyFence; +PFN_vkResetFences vulkan_symbol_wrapper_vkResetFences; +PFN_vkGetFenceStatus vulkan_symbol_wrapper_vkGetFenceStatus; +PFN_vkWaitForFences vulkan_symbol_wrapper_vkWaitForFences; +PFN_vkCreateSemaphore vulkan_symbol_wrapper_vkCreateSemaphore; +PFN_vkDestroySemaphore vulkan_symbol_wrapper_vkDestroySemaphore; +PFN_vkCreateEvent vulkan_symbol_wrapper_vkCreateEvent; +PFN_vkDestroyEvent vulkan_symbol_wrapper_vkDestroyEvent; +PFN_vkGetEventStatus vulkan_symbol_wrapper_vkGetEventStatus; +PFN_vkSetEvent vulkan_symbol_wrapper_vkSetEvent; +PFN_vkResetEvent vulkan_symbol_wrapper_vkResetEvent; +PFN_vkCreateQueryPool vulkan_symbol_wrapper_vkCreateQueryPool; +PFN_vkDestroyQueryPool vulkan_symbol_wrapper_vkDestroyQueryPool; +PFN_vkGetQueryPoolResults vulkan_symbol_wrapper_vkGetQueryPoolResults; +PFN_vkCreateBuffer vulkan_symbol_wrapper_vkCreateBuffer; +PFN_vkDestroyBuffer vulkan_symbol_wrapper_vkDestroyBuffer; +PFN_vkCreateBufferView vulkan_symbol_wrapper_vkCreateBufferView; +PFN_vkDestroyBufferView vulkan_symbol_wrapper_vkDestroyBufferView; +PFN_vkCreateImage vulkan_symbol_wrapper_vkCreateImage; +PFN_vkDestroyImage vulkan_symbol_wrapper_vkDestroyImage; +PFN_vkGetImageSubresourceLayout vulkan_symbol_wrapper_vkGetImageSubresourceLayout; +PFN_vkCreateImageView vulkan_symbol_wrapper_vkCreateImageView; +PFN_vkDestroyImageView vulkan_symbol_wrapper_vkDestroyImageView; +PFN_vkCreateShaderModule vulkan_symbol_wrapper_vkCreateShaderModule; +PFN_vkDestroyShaderModule vulkan_symbol_wrapper_vkDestroyShaderModule; +PFN_vkCreatePipelineCache vulkan_symbol_wrapper_vkCreatePipelineCache; +PFN_vkDestroyPipelineCache vulkan_symbol_wrapper_vkDestroyPipelineCache; +PFN_vkGetPipelineCacheData vulkan_symbol_wrapper_vkGetPipelineCacheData; +PFN_vkMergePipelineCaches vulkan_symbol_wrapper_vkMergePipelineCaches; +PFN_vkCreateGraphicsPipelines vulkan_symbol_wrapper_vkCreateGraphicsPipelines; +PFN_vkCreateComputePipelines vulkan_symbol_wrapper_vkCreateComputePipelines; +PFN_vkDestroyPipeline vulkan_symbol_wrapper_vkDestroyPipeline; +PFN_vkCreatePipelineLayout vulkan_symbol_wrapper_vkCreatePipelineLayout; +PFN_vkDestroyPipelineLayout vulkan_symbol_wrapper_vkDestroyPipelineLayout; +PFN_vkCreateSampler vulkan_symbol_wrapper_vkCreateSampler; +PFN_vkDestroySampler vulkan_symbol_wrapper_vkDestroySampler; +PFN_vkCreateDescriptorSetLayout vulkan_symbol_wrapper_vkCreateDescriptorSetLayout; +PFN_vkDestroyDescriptorSetLayout vulkan_symbol_wrapper_vkDestroyDescriptorSetLayout; +PFN_vkCreateDescriptorPool vulkan_symbol_wrapper_vkCreateDescriptorPool; +PFN_vkDestroyDescriptorPool vulkan_symbol_wrapper_vkDestroyDescriptorPool; +PFN_vkResetDescriptorPool vulkan_symbol_wrapper_vkResetDescriptorPool; +PFN_vkAllocateDescriptorSets vulkan_symbol_wrapper_vkAllocateDescriptorSets; +PFN_vkFreeDescriptorSets vulkan_symbol_wrapper_vkFreeDescriptorSets; +PFN_vkUpdateDescriptorSets vulkan_symbol_wrapper_vkUpdateDescriptorSets; +PFN_vkCreateFramebuffer vulkan_symbol_wrapper_vkCreateFramebuffer; +PFN_vkDestroyFramebuffer vulkan_symbol_wrapper_vkDestroyFramebuffer; +PFN_vkCreateRenderPass vulkan_symbol_wrapper_vkCreateRenderPass; +PFN_vkDestroyRenderPass vulkan_symbol_wrapper_vkDestroyRenderPass; +PFN_vkGetRenderAreaGranularity vulkan_symbol_wrapper_vkGetRenderAreaGranularity; +PFN_vkCreateCommandPool vulkan_symbol_wrapper_vkCreateCommandPool; +PFN_vkDestroyCommandPool vulkan_symbol_wrapper_vkDestroyCommandPool; +PFN_vkResetCommandPool vulkan_symbol_wrapper_vkResetCommandPool; +PFN_vkAllocateCommandBuffers vulkan_symbol_wrapper_vkAllocateCommandBuffers; +PFN_vkFreeCommandBuffers vulkan_symbol_wrapper_vkFreeCommandBuffers; +PFN_vkBeginCommandBuffer vulkan_symbol_wrapper_vkBeginCommandBuffer; +PFN_vkEndCommandBuffer vulkan_symbol_wrapper_vkEndCommandBuffer; +PFN_vkResetCommandBuffer vulkan_symbol_wrapper_vkResetCommandBuffer; +PFN_vkCmdBindPipeline vulkan_symbol_wrapper_vkCmdBindPipeline; +PFN_vkCmdSetViewport vulkan_symbol_wrapper_vkCmdSetViewport; +PFN_vkCmdSetScissor vulkan_symbol_wrapper_vkCmdSetScissor; +PFN_vkCmdSetLineWidth vulkan_symbol_wrapper_vkCmdSetLineWidth; +PFN_vkCmdSetDepthBias vulkan_symbol_wrapper_vkCmdSetDepthBias; +PFN_vkCmdSetBlendConstants vulkan_symbol_wrapper_vkCmdSetBlendConstants; +PFN_vkCmdSetDepthBounds vulkan_symbol_wrapper_vkCmdSetDepthBounds; +PFN_vkCmdSetStencilCompareMask vulkan_symbol_wrapper_vkCmdSetStencilCompareMask; +PFN_vkCmdSetStencilWriteMask vulkan_symbol_wrapper_vkCmdSetStencilWriteMask; +PFN_vkCmdSetStencilReference vulkan_symbol_wrapper_vkCmdSetStencilReference; +PFN_vkCmdBindDescriptorSets vulkan_symbol_wrapper_vkCmdBindDescriptorSets; +PFN_vkCmdBindIndexBuffer vulkan_symbol_wrapper_vkCmdBindIndexBuffer; +PFN_vkCmdBindVertexBuffers vulkan_symbol_wrapper_vkCmdBindVertexBuffers; +PFN_vkCmdDraw vulkan_symbol_wrapper_vkCmdDraw; +PFN_vkCmdDrawIndexed vulkan_symbol_wrapper_vkCmdDrawIndexed; +PFN_vkCmdDrawIndirect vulkan_symbol_wrapper_vkCmdDrawIndirect; +PFN_vkCmdDrawIndexedIndirect vulkan_symbol_wrapper_vkCmdDrawIndexedIndirect; +PFN_vkCmdDispatch vulkan_symbol_wrapper_vkCmdDispatch; +PFN_vkCmdDispatchIndirect vulkan_symbol_wrapper_vkCmdDispatchIndirect; +PFN_vkCmdCopyBuffer vulkan_symbol_wrapper_vkCmdCopyBuffer; +PFN_vkCmdCopyImage vulkan_symbol_wrapper_vkCmdCopyImage; +PFN_vkCmdBlitImage vulkan_symbol_wrapper_vkCmdBlitImage; +PFN_vkCmdCopyBufferToImage vulkan_symbol_wrapper_vkCmdCopyBufferToImage; +PFN_vkCmdCopyImageToBuffer vulkan_symbol_wrapper_vkCmdCopyImageToBuffer; +PFN_vkCmdUpdateBuffer vulkan_symbol_wrapper_vkCmdUpdateBuffer; +PFN_vkCmdFillBuffer vulkan_symbol_wrapper_vkCmdFillBuffer; +PFN_vkCmdClearColorImage vulkan_symbol_wrapper_vkCmdClearColorImage; +PFN_vkCmdClearDepthStencilImage vulkan_symbol_wrapper_vkCmdClearDepthStencilImage; +PFN_vkCmdClearAttachments vulkan_symbol_wrapper_vkCmdClearAttachments; +PFN_vkCmdResolveImage vulkan_symbol_wrapper_vkCmdResolveImage; +PFN_vkCmdSetEvent vulkan_symbol_wrapper_vkCmdSetEvent; +PFN_vkCmdResetEvent vulkan_symbol_wrapper_vkCmdResetEvent; +PFN_vkCmdWaitEvents vulkan_symbol_wrapper_vkCmdWaitEvents; +PFN_vkCmdPipelineBarrier vulkan_symbol_wrapper_vkCmdPipelineBarrier; +PFN_vkCmdBeginQuery vulkan_symbol_wrapper_vkCmdBeginQuery; +PFN_vkCmdEndQuery vulkan_symbol_wrapper_vkCmdEndQuery; +PFN_vkCmdResetQueryPool vulkan_symbol_wrapper_vkCmdResetQueryPool; +PFN_vkCmdWriteTimestamp vulkan_symbol_wrapper_vkCmdWriteTimestamp; +PFN_vkCmdCopyQueryPoolResults vulkan_symbol_wrapper_vkCmdCopyQueryPoolResults; +PFN_vkCmdPushConstants vulkan_symbol_wrapper_vkCmdPushConstants; +PFN_vkCmdBeginRenderPass vulkan_symbol_wrapper_vkCmdBeginRenderPass; +PFN_vkCmdNextSubpass vulkan_symbol_wrapper_vkCmdNextSubpass; +PFN_vkCmdEndRenderPass vulkan_symbol_wrapper_vkCmdEndRenderPass; +PFN_vkCmdExecuteCommands vulkan_symbol_wrapper_vkCmdExecuteCommands; +PFN_vkEnumerateInstanceVersion vulkan_symbol_wrapper_vkEnumerateInstanceVersion; +PFN_vkBindBufferMemory2 vulkan_symbol_wrapper_vkBindBufferMemory2; +PFN_vkBindImageMemory2 vulkan_symbol_wrapper_vkBindImageMemory2; +PFN_vkGetDeviceGroupPeerMemoryFeatures vulkan_symbol_wrapper_vkGetDeviceGroupPeerMemoryFeatures; +PFN_vkCmdSetDeviceMask vulkan_symbol_wrapper_vkCmdSetDeviceMask; +PFN_vkCmdDispatchBase vulkan_symbol_wrapper_vkCmdDispatchBase; +PFN_vkEnumeratePhysicalDeviceGroups vulkan_symbol_wrapper_vkEnumeratePhysicalDeviceGroups; +PFN_vkGetImageMemoryRequirements2 vulkan_symbol_wrapper_vkGetImageMemoryRequirements2; +PFN_vkGetBufferMemoryRequirements2 vulkan_symbol_wrapper_vkGetBufferMemoryRequirements2; +PFN_vkGetImageSparseMemoryRequirements2 vulkan_symbol_wrapper_vkGetImageSparseMemoryRequirements2; +PFN_vkGetPhysicalDeviceFeatures2 vulkan_symbol_wrapper_vkGetPhysicalDeviceFeatures2; +PFN_vkGetPhysicalDeviceProperties2 vulkan_symbol_wrapper_vkGetPhysicalDeviceProperties2; +PFN_vkGetPhysicalDeviceFormatProperties2 vulkan_symbol_wrapper_vkGetPhysicalDeviceFormatProperties2; +PFN_vkGetPhysicalDeviceImageFormatProperties2 vulkan_symbol_wrapper_vkGetPhysicalDeviceImageFormatProperties2; +PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vulkan_symbol_wrapper_vkGetPhysicalDeviceQueueFamilyProperties2; +PFN_vkGetPhysicalDeviceMemoryProperties2 vulkan_symbol_wrapper_vkGetPhysicalDeviceMemoryProperties2; +PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vulkan_symbol_wrapper_vkGetPhysicalDeviceSparseImageFormatProperties2; +PFN_vkTrimCommandPool vulkan_symbol_wrapper_vkTrimCommandPool; +PFN_vkGetDeviceQueue2 vulkan_symbol_wrapper_vkGetDeviceQueue2; +PFN_vkCreateSamplerYcbcrConversion vulkan_symbol_wrapper_vkCreateSamplerYcbcrConversion; +PFN_vkDestroySamplerYcbcrConversion vulkan_symbol_wrapper_vkDestroySamplerYcbcrConversion; +PFN_vkCreateDescriptorUpdateTemplate vulkan_symbol_wrapper_vkCreateDescriptorUpdateTemplate; +PFN_vkDestroyDescriptorUpdateTemplate vulkan_symbol_wrapper_vkDestroyDescriptorUpdateTemplate; +PFN_vkUpdateDescriptorSetWithTemplate vulkan_symbol_wrapper_vkUpdateDescriptorSetWithTemplate; +PFN_vkGetPhysicalDeviceExternalBufferProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalBufferProperties; +PFN_vkGetPhysicalDeviceExternalFenceProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalFenceProperties; +PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalSemaphoreProperties; +PFN_vkGetDescriptorSetLayoutSupport vulkan_symbol_wrapper_vkGetDescriptorSetLayoutSupport; +PFN_vkGetImageViewHandleNVX vulkan_symbol_wrapper_vkGetImageViewHandleNVX; +PFN_vkCmdDrawIndirectCountAMD vulkan_symbol_wrapper_vkCmdDrawIndirectCountAMD; +PFN_vkCmdDrawIndexedIndirectCountAMD vulkan_symbol_wrapper_vkCmdDrawIndexedIndirectCountAMD; +PFN_vkGetShaderInfoAMD vulkan_symbol_wrapper_vkGetShaderInfoAMD; +PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalImageFormatPropertiesNV; +PFN_vkCmdProcessCommandsNVX vulkan_symbol_wrapper_vkCmdProcessCommandsNVX; +PFN_vkCmdReserveSpaceForCommandsNVX vulkan_symbol_wrapper_vkCmdReserveSpaceForCommandsNVX; +PFN_vkCreateIndirectCommandsLayoutNVX vulkan_symbol_wrapper_vkCreateIndirectCommandsLayoutNVX; +PFN_vkDestroyIndirectCommandsLayoutNVX vulkan_symbol_wrapper_vkDestroyIndirectCommandsLayoutNVX; +PFN_vkCreateObjectTableNVX vulkan_symbol_wrapper_vkCreateObjectTableNVX; +PFN_vkDestroyObjectTableNVX vulkan_symbol_wrapper_vkDestroyObjectTableNVX; +PFN_vkRegisterObjectsNVX vulkan_symbol_wrapper_vkRegisterObjectsNVX; +PFN_vkUnregisterObjectsNVX vulkan_symbol_wrapper_vkUnregisterObjectsNVX; +PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX vulkan_symbol_wrapper_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX; +PFN_vkCmdSetViewportWScalingNV vulkan_symbol_wrapper_vkCmdSetViewportWScalingNV; +PFN_vkGetRefreshCycleDurationGOOGLE vulkan_symbol_wrapper_vkGetRefreshCycleDurationGOOGLE; +PFN_vkGetPastPresentationTimingGOOGLE vulkan_symbol_wrapper_vkGetPastPresentationTimingGOOGLE; +PFN_vkCmdBindShadingRateImageNV vulkan_symbol_wrapper_vkCmdBindShadingRateImageNV; +PFN_vkCmdSetViewportShadingRatePaletteNV vulkan_symbol_wrapper_vkCmdSetViewportShadingRatePaletteNV; +PFN_vkCmdSetCoarseSampleOrderNV vulkan_symbol_wrapper_vkCmdSetCoarseSampleOrderNV; +PFN_vkCreateAccelerationStructureNV vulkan_symbol_wrapper_vkCreateAccelerationStructureNV; +PFN_vkDestroyAccelerationStructureNV vulkan_symbol_wrapper_vkDestroyAccelerationStructureNV; +PFN_vkGetAccelerationStructureMemoryRequirementsNV vulkan_symbol_wrapper_vkGetAccelerationStructureMemoryRequirementsNV; +PFN_vkBindAccelerationStructureMemoryNV vulkan_symbol_wrapper_vkBindAccelerationStructureMemoryNV; +PFN_vkCmdBuildAccelerationStructureNV vulkan_symbol_wrapper_vkCmdBuildAccelerationStructureNV; +PFN_vkCmdCopyAccelerationStructureNV vulkan_symbol_wrapper_vkCmdCopyAccelerationStructureNV; +PFN_vkCmdTraceRaysNV vulkan_symbol_wrapper_vkCmdTraceRaysNV; +PFN_vkCreateRayTracingPipelinesNV vulkan_symbol_wrapper_vkCreateRayTracingPipelinesNV; +PFN_vkGetRayTracingShaderGroupHandlesNV vulkan_symbol_wrapper_vkGetRayTracingShaderGroupHandlesNV; +PFN_vkGetAccelerationStructureHandleNV vulkan_symbol_wrapper_vkGetAccelerationStructureHandleNV; +PFN_vkCmdWriteAccelerationStructuresPropertiesNV vulkan_symbol_wrapper_vkCmdWriteAccelerationStructuresPropertiesNV; +PFN_vkCompileDeferredNV vulkan_symbol_wrapper_vkCompileDeferredNV; +PFN_vkCmdWriteBufferMarkerAMD vulkan_symbol_wrapper_vkCmdWriteBufferMarkerAMD; +PFN_vkCmdDrawMeshTasksNV vulkan_symbol_wrapper_vkCmdDrawMeshTasksNV; +PFN_vkCmdDrawMeshTasksIndirectNV vulkan_symbol_wrapper_vkCmdDrawMeshTasksIndirectNV; +PFN_vkCmdDrawMeshTasksIndirectCountNV vulkan_symbol_wrapper_vkCmdDrawMeshTasksIndirectCountNV; +PFN_vkCmdSetExclusiveScissorNV vulkan_symbol_wrapper_vkCmdSetExclusiveScissorNV; +PFN_vkCmdSetCheckpointNV vulkan_symbol_wrapper_vkCmdSetCheckpointNV; +PFN_vkGetQueueCheckpointDataNV vulkan_symbol_wrapper_vkGetQueueCheckpointDataNV; +PFN_vkInitializePerformanceApiINTEL vulkan_symbol_wrapper_vkInitializePerformanceApiINTEL; +PFN_vkUninitializePerformanceApiINTEL vulkan_symbol_wrapper_vkUninitializePerformanceApiINTEL; +PFN_vkCmdSetPerformanceMarkerINTEL vulkan_symbol_wrapper_vkCmdSetPerformanceMarkerINTEL; +PFN_vkCmdSetPerformanceStreamMarkerINTEL vulkan_symbol_wrapper_vkCmdSetPerformanceStreamMarkerINTEL; +PFN_vkCmdSetPerformanceOverrideINTEL vulkan_symbol_wrapper_vkCmdSetPerformanceOverrideINTEL; +PFN_vkAcquirePerformanceConfigurationINTEL vulkan_symbol_wrapper_vkAcquirePerformanceConfigurationINTEL; +PFN_vkReleasePerformanceConfigurationINTEL vulkan_symbol_wrapper_vkReleasePerformanceConfigurationINTEL; +PFN_vkQueueSetPerformanceConfigurationINTEL vulkan_symbol_wrapper_vkQueueSetPerformanceConfigurationINTEL; +PFN_vkGetPerformanceParameterINTEL vulkan_symbol_wrapper_vkGetPerformanceParameterINTEL; +PFN_vkSetLocalDimmingAMD vulkan_symbol_wrapper_vkSetLocalDimmingAMD; +PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vulkan_symbol_wrapper_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; +PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vulkan_symbol_wrapper_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; +PFN_vkDestroySurfaceKHR vulkan_symbol_wrapper_vkDestroySurfaceKHR; +PFN_vkGetPhysicalDeviceSurfaceSupportKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfaceSupportKHR; +PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; +PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfaceFormatsKHR; +PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfacePresentModesKHR; +PFN_vkCreateSwapchainKHR vulkan_symbol_wrapper_vkCreateSwapchainKHR; +PFN_vkDestroySwapchainKHR vulkan_symbol_wrapper_vkDestroySwapchainKHR; +PFN_vkGetSwapchainImagesKHR vulkan_symbol_wrapper_vkGetSwapchainImagesKHR; +PFN_vkAcquireNextImageKHR vulkan_symbol_wrapper_vkAcquireNextImageKHR; +PFN_vkQueuePresentKHR vulkan_symbol_wrapper_vkQueuePresentKHR; +PFN_vkGetDeviceGroupPresentCapabilitiesKHR vulkan_symbol_wrapper_vkGetDeviceGroupPresentCapabilitiesKHR; +PFN_vkGetDeviceGroupSurfacePresentModesKHR vulkan_symbol_wrapper_vkGetDeviceGroupSurfacePresentModesKHR; +PFN_vkGetPhysicalDevicePresentRectanglesKHR vulkan_symbol_wrapper_vkGetPhysicalDevicePresentRectanglesKHR; +PFN_vkAcquireNextImage2KHR vulkan_symbol_wrapper_vkAcquireNextImage2KHR; +PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceDisplayPropertiesKHR; +PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceDisplayPlanePropertiesKHR; +PFN_vkGetDisplayPlaneSupportedDisplaysKHR vulkan_symbol_wrapper_vkGetDisplayPlaneSupportedDisplaysKHR; +PFN_vkGetDisplayModePropertiesKHR vulkan_symbol_wrapper_vkGetDisplayModePropertiesKHR; +PFN_vkCreateDisplayModeKHR vulkan_symbol_wrapper_vkCreateDisplayModeKHR; +PFN_vkGetDisplayPlaneCapabilitiesKHR vulkan_symbol_wrapper_vkGetDisplayPlaneCapabilitiesKHR; +PFN_vkCreateDisplayPlaneSurfaceKHR vulkan_symbol_wrapper_vkCreateDisplayPlaneSurfaceKHR; +PFN_vkCreateSharedSwapchainsKHR vulkan_symbol_wrapper_vkCreateSharedSwapchainsKHR; +PFN_vkGetPhysicalDeviceFeatures2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceFeatures2KHR; +PFN_vkGetPhysicalDeviceProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceProperties2KHR; +PFN_vkGetPhysicalDeviceFormatProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceFormatProperties2KHR; +PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceImageFormatProperties2KHR; +PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceQueueFamilyProperties2KHR; +PFN_vkGetPhysicalDeviceMemoryProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceMemoryProperties2KHR; +PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSparseImageFormatProperties2KHR; +PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vulkan_symbol_wrapper_vkGetDeviceGroupPeerMemoryFeaturesKHR; +PFN_vkCmdSetDeviceMaskKHR vulkan_symbol_wrapper_vkCmdSetDeviceMaskKHR; +PFN_vkCmdDispatchBaseKHR vulkan_symbol_wrapper_vkCmdDispatchBaseKHR; +PFN_vkTrimCommandPoolKHR vulkan_symbol_wrapper_vkTrimCommandPoolKHR; +PFN_vkEnumeratePhysicalDeviceGroupsKHR vulkan_symbol_wrapper_vkEnumeratePhysicalDeviceGroupsKHR; +PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalBufferPropertiesKHR; +PFN_vkGetMemoryFdKHR vulkan_symbol_wrapper_vkGetMemoryFdKHR; +PFN_vkGetMemoryFdPropertiesKHR vulkan_symbol_wrapper_vkGetMemoryFdPropertiesKHR; +PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; +PFN_vkImportSemaphoreFdKHR vulkan_symbol_wrapper_vkImportSemaphoreFdKHR; +PFN_vkGetSemaphoreFdKHR vulkan_symbol_wrapper_vkGetSemaphoreFdKHR; +PFN_vkCmdPushDescriptorSetKHR vulkan_symbol_wrapper_vkCmdPushDescriptorSetKHR; +PFN_vkCmdPushDescriptorSetWithTemplateKHR vulkan_symbol_wrapper_vkCmdPushDescriptorSetWithTemplateKHR; +PFN_vkCreateDescriptorUpdateTemplateKHR vulkan_symbol_wrapper_vkCreateDescriptorUpdateTemplateKHR; +PFN_vkDestroyDescriptorUpdateTemplateKHR vulkan_symbol_wrapper_vkDestroyDescriptorUpdateTemplateKHR; +PFN_vkUpdateDescriptorSetWithTemplateKHR vulkan_symbol_wrapper_vkUpdateDescriptorSetWithTemplateKHR; +PFN_vkCreateRenderPass2KHR vulkan_symbol_wrapper_vkCreateRenderPass2KHR; +PFN_vkCmdBeginRenderPass2KHR vulkan_symbol_wrapper_vkCmdBeginRenderPass2KHR; +PFN_vkCmdNextSubpass2KHR vulkan_symbol_wrapper_vkCmdNextSubpass2KHR; +PFN_vkCmdEndRenderPass2KHR vulkan_symbol_wrapper_vkCmdEndRenderPass2KHR; +PFN_vkGetSwapchainStatusKHR vulkan_symbol_wrapper_vkGetSwapchainStatusKHR; +PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vulkan_symbol_wrapper_vkGetPhysicalDeviceExternalFencePropertiesKHR; +PFN_vkImportFenceFdKHR vulkan_symbol_wrapper_vkImportFenceFdKHR; +PFN_vkGetFenceFdKHR vulkan_symbol_wrapper_vkGetFenceFdKHR; +PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfaceCapabilities2KHR; +PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfaceFormats2KHR; +PFN_vkGetPhysicalDeviceDisplayProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceDisplayProperties2KHR; +PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vulkan_symbol_wrapper_vkGetPhysicalDeviceDisplayPlaneProperties2KHR; +PFN_vkGetDisplayModeProperties2KHR vulkan_symbol_wrapper_vkGetDisplayModeProperties2KHR; +PFN_vkGetDisplayPlaneCapabilities2KHR vulkan_symbol_wrapper_vkGetDisplayPlaneCapabilities2KHR; +PFN_vkGetImageMemoryRequirements2KHR vulkan_symbol_wrapper_vkGetImageMemoryRequirements2KHR; +PFN_vkGetBufferMemoryRequirements2KHR vulkan_symbol_wrapper_vkGetBufferMemoryRequirements2KHR; +PFN_vkGetImageSparseMemoryRequirements2KHR vulkan_symbol_wrapper_vkGetImageSparseMemoryRequirements2KHR; +PFN_vkCreateSamplerYcbcrConversionKHR vulkan_symbol_wrapper_vkCreateSamplerYcbcrConversionKHR; +PFN_vkDestroySamplerYcbcrConversionKHR vulkan_symbol_wrapper_vkDestroySamplerYcbcrConversionKHR; +PFN_vkBindBufferMemory2KHR vulkan_symbol_wrapper_vkBindBufferMemory2KHR; +PFN_vkBindImageMemory2KHR vulkan_symbol_wrapper_vkBindImageMemory2KHR; +PFN_vkGetDescriptorSetLayoutSupportKHR vulkan_symbol_wrapper_vkGetDescriptorSetLayoutSupportKHR; +PFN_vkCmdDrawIndirectCountKHR vulkan_symbol_wrapper_vkCmdDrawIndirectCountKHR; +PFN_vkCmdDrawIndexedIndirectCountKHR vulkan_symbol_wrapper_vkCmdDrawIndexedIndirectCountKHR; +PFN_vkGetPipelineExecutablePropertiesKHR vulkan_symbol_wrapper_vkGetPipelineExecutablePropertiesKHR; +PFN_vkGetPipelineExecutableStatisticsKHR vulkan_symbol_wrapper_vkGetPipelineExecutableStatisticsKHR; +PFN_vkGetPipelineExecutableInternalRepresentationsKHR vulkan_symbol_wrapper_vkGetPipelineExecutableInternalRepresentationsKHR; +PFN_vkCreateDebugReportCallbackEXT vulkan_symbol_wrapper_vkCreateDebugReportCallbackEXT; +PFN_vkDestroyDebugReportCallbackEXT vulkan_symbol_wrapper_vkDestroyDebugReportCallbackEXT; +PFN_vkDebugReportMessageEXT vulkan_symbol_wrapper_vkDebugReportMessageEXT; +PFN_vkDebugMarkerSetObjectTagEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectTagEXT; +PFN_vkDebugMarkerSetObjectNameEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectNameEXT; +PFN_vkCmdDebugMarkerBeginEXT vulkan_symbol_wrapper_vkCmdDebugMarkerBeginEXT; +PFN_vkCmdDebugMarkerEndEXT vulkan_symbol_wrapper_vkCmdDebugMarkerEndEXT; +PFN_vkCmdDebugMarkerInsertEXT vulkan_symbol_wrapper_vkCmdDebugMarkerInsertEXT; +PFN_vkCmdBindTransformFeedbackBuffersEXT vulkan_symbol_wrapper_vkCmdBindTransformFeedbackBuffersEXT; +PFN_vkCmdBeginTransformFeedbackEXT vulkan_symbol_wrapper_vkCmdBeginTransformFeedbackEXT; +PFN_vkCmdEndTransformFeedbackEXT vulkan_symbol_wrapper_vkCmdEndTransformFeedbackEXT; +PFN_vkCmdBeginQueryIndexedEXT vulkan_symbol_wrapper_vkCmdBeginQueryIndexedEXT; +PFN_vkCmdEndQueryIndexedEXT vulkan_symbol_wrapper_vkCmdEndQueryIndexedEXT; +PFN_vkCmdDrawIndirectByteCountEXT vulkan_symbol_wrapper_vkCmdDrawIndirectByteCountEXT; +PFN_vkCmdBeginConditionalRenderingEXT vulkan_symbol_wrapper_vkCmdBeginConditionalRenderingEXT; +PFN_vkCmdEndConditionalRenderingEXT vulkan_symbol_wrapper_vkCmdEndConditionalRenderingEXT; +PFN_vkReleaseDisplayEXT vulkan_symbol_wrapper_vkReleaseDisplayEXT; +PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vulkan_symbol_wrapper_vkGetPhysicalDeviceSurfaceCapabilities2EXT; +PFN_vkDisplayPowerControlEXT vulkan_symbol_wrapper_vkDisplayPowerControlEXT; +PFN_vkRegisterDeviceEventEXT vulkan_symbol_wrapper_vkRegisterDeviceEventEXT; +PFN_vkRegisterDisplayEventEXT vulkan_symbol_wrapper_vkRegisterDisplayEventEXT; +PFN_vkGetSwapchainCounterEXT vulkan_symbol_wrapper_vkGetSwapchainCounterEXT; +PFN_vkCmdSetDiscardRectangleEXT vulkan_symbol_wrapper_vkCmdSetDiscardRectangleEXT; +PFN_vkSetHdrMetadataEXT vulkan_symbol_wrapper_vkSetHdrMetadataEXT; +PFN_vkSetDebugUtilsObjectNameEXT vulkan_symbol_wrapper_vkSetDebugUtilsObjectNameEXT; +PFN_vkSetDebugUtilsObjectTagEXT vulkan_symbol_wrapper_vkSetDebugUtilsObjectTagEXT; +PFN_vkQueueBeginDebugUtilsLabelEXT vulkan_symbol_wrapper_vkQueueBeginDebugUtilsLabelEXT; +PFN_vkQueueEndDebugUtilsLabelEXT vulkan_symbol_wrapper_vkQueueEndDebugUtilsLabelEXT; +PFN_vkQueueInsertDebugUtilsLabelEXT vulkan_symbol_wrapper_vkQueueInsertDebugUtilsLabelEXT; +PFN_vkCmdBeginDebugUtilsLabelEXT vulkan_symbol_wrapper_vkCmdBeginDebugUtilsLabelEXT; +PFN_vkCmdEndDebugUtilsLabelEXT vulkan_symbol_wrapper_vkCmdEndDebugUtilsLabelEXT; +PFN_vkCmdInsertDebugUtilsLabelEXT vulkan_symbol_wrapper_vkCmdInsertDebugUtilsLabelEXT; +PFN_vkCreateDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkCreateDebugUtilsMessengerEXT; +PFN_vkDestroyDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkDestroyDebugUtilsMessengerEXT; +PFN_vkSubmitDebugUtilsMessageEXT vulkan_symbol_wrapper_vkSubmitDebugUtilsMessageEXT; +PFN_vkCmdSetSampleLocationsEXT vulkan_symbol_wrapper_vkCmdSetSampleLocationsEXT; +PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vulkan_symbol_wrapper_vkGetPhysicalDeviceMultisamplePropertiesEXT; +PFN_vkGetImageDrmFormatModifierPropertiesEXT vulkan_symbol_wrapper_vkGetImageDrmFormatModifierPropertiesEXT; +PFN_vkCreateValidationCacheEXT vulkan_symbol_wrapper_vkCreateValidationCacheEXT; +PFN_vkDestroyValidationCacheEXT vulkan_symbol_wrapper_vkDestroyValidationCacheEXT; +PFN_vkMergeValidationCachesEXT vulkan_symbol_wrapper_vkMergeValidationCachesEXT; +PFN_vkGetValidationCacheDataEXT vulkan_symbol_wrapper_vkGetValidationCacheDataEXT; +PFN_vkGetMemoryHostPointerPropertiesEXT vulkan_symbol_wrapper_vkGetMemoryHostPointerPropertiesEXT; +PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vulkan_symbol_wrapper_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; +PFN_vkGetCalibratedTimestampsEXT vulkan_symbol_wrapper_vkGetCalibratedTimestampsEXT; +PFN_vkGetBufferDeviceAddressEXT vulkan_symbol_wrapper_vkGetBufferDeviceAddressEXT; +PFN_vkCreateHeadlessSurfaceEXT vulkan_symbol_wrapper_vkCreateHeadlessSurfaceEXT; +PFN_vkCmdSetLineStippleEXT vulkan_symbol_wrapper_vkCmdSetLineStippleEXT; +PFN_vkResetQueryPoolEXT vulkan_symbol_wrapper_vkResetQueryPoolEXT; + +static PFN_vkGetInstanceProcAddr GetInstanceProcAddr; +void vulkan_symbol_wrapper_init(PFN_vkGetInstanceProcAddr get_instance_proc_addr) +{ + GetInstanceProcAddr = get_instance_proc_addr; +} + +PFN_vkGetInstanceProcAddr vulkan_symbol_wrapper_instance_proc_addr(void) +{ + return GetInstanceProcAddr; +} + + +VkBool32 vulkan_symbol_wrapper_load_instance_symbol(VkInstance instance, const char *name, PFN_vkVoidFunction *ppSymbol) +{ + *ppSymbol = GetInstanceProcAddr(instance, name); + return *ppSymbol != NULL; +} + +VkBool32 vulkan_symbol_wrapper_load_device_symbol(VkDevice device, const char *name, PFN_vkVoidFunction *ppSymbol) +{ + *ppSymbol = vkGetDeviceProcAddr(device, name); + return *ppSymbol != NULL; +} + +VkBool32 vulkan_symbol_wrapper_load_global_symbols(void) +{ + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkCreateInstance", vkCreateInstance)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkEnumerateInstanceExtensionProperties", vkEnumerateInstanceExtensionProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkEnumerateInstanceLayerProperties", vkEnumerateInstanceLayerProperties)) return VK_FALSE; + return VK_TRUE; +} + +VkBool32 vulkan_symbol_wrapper_load_core_symbols(VkInstance instance) +{ + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyInstance", vkDestroyInstance)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumeratePhysicalDevices", vkEnumeratePhysicalDevices)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFeatures", vkGetPhysicalDeviceFeatures)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFormatProperties", vkGetPhysicalDeviceFormatProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceImageFormatProperties", vkGetPhysicalDeviceImageFormatProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceProperties", vkGetPhysicalDeviceProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceQueueFamilyProperties", vkGetPhysicalDeviceQueueFamilyProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceMemoryProperties", vkGetPhysicalDeviceMemoryProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDeviceProcAddr", vkGetDeviceProcAddr)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateDevice", vkCreateDevice)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyDevice", vkDestroyDevice)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumerateDeviceExtensionProperties", vkEnumerateDeviceExtensionProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumerateDeviceLayerProperties", vkEnumerateDeviceLayerProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDeviceQueue", vkGetDeviceQueue)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkQueueSubmit", vkQueueSubmit)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkQueueWaitIdle", vkQueueWaitIdle)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDeviceWaitIdle", vkDeviceWaitIdle)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkAllocateMemory", vkAllocateMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkFreeMemory", vkFreeMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkMapMemory", vkMapMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkUnmapMemory", vkUnmapMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkFlushMappedMemoryRanges", vkFlushMappedMemoryRanges)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkInvalidateMappedMemoryRanges", vkInvalidateMappedMemoryRanges)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDeviceMemoryCommitment", vkGetDeviceMemoryCommitment)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkBindBufferMemory", vkBindBufferMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkBindImageMemory", vkBindImageMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetBufferMemoryRequirements", vkGetBufferMemoryRequirements)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetImageMemoryRequirements", vkGetImageMemoryRequirements)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetImageSparseMemoryRequirements", vkGetImageSparseMemoryRequirements)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceSparseImageFormatProperties", vkGetPhysicalDeviceSparseImageFormatProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkQueueBindSparse", vkQueueBindSparse)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateFence", vkCreateFence)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyFence", vkDestroyFence)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkResetFences", vkResetFences)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetFenceStatus", vkGetFenceStatus)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkWaitForFences", vkWaitForFences)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateSemaphore", vkCreateSemaphore)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroySemaphore", vkDestroySemaphore)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateEvent", vkCreateEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyEvent", vkDestroyEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetEventStatus", vkGetEventStatus)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkSetEvent", vkSetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkResetEvent", vkResetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateQueryPool", vkCreateQueryPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyQueryPool", vkDestroyQueryPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetQueryPoolResults", vkGetQueryPoolResults)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateBuffer", vkCreateBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyBuffer", vkDestroyBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateBufferView", vkCreateBufferView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyBufferView", vkDestroyBufferView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateImage", vkCreateImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyImage", vkDestroyImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetImageSubresourceLayout", vkGetImageSubresourceLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateImageView", vkCreateImageView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyImageView", vkDestroyImageView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateShaderModule", vkCreateShaderModule)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyShaderModule", vkDestroyShaderModule)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreatePipelineCache", vkCreatePipelineCache)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyPipelineCache", vkDestroyPipelineCache)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPipelineCacheData", vkGetPipelineCacheData)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkMergePipelineCaches", vkMergePipelineCaches)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateGraphicsPipelines", vkCreateGraphicsPipelines)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateComputePipelines", vkCreateComputePipelines)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyPipeline", vkDestroyPipeline)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreatePipelineLayout", vkCreatePipelineLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyPipelineLayout", vkDestroyPipelineLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateSampler", vkCreateSampler)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroySampler", vkDestroySampler)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateDescriptorSetLayout", vkCreateDescriptorSetLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyDescriptorSetLayout", vkDestroyDescriptorSetLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateDescriptorPool", vkCreateDescriptorPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyDescriptorPool", vkDestroyDescriptorPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkResetDescriptorPool", vkResetDescriptorPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkAllocateDescriptorSets", vkAllocateDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkFreeDescriptorSets", vkFreeDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkUpdateDescriptorSets", vkUpdateDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateFramebuffer", vkCreateFramebuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyFramebuffer", vkDestroyFramebuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateRenderPass", vkCreateRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyRenderPass", vkDestroyRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetRenderAreaGranularity", vkGetRenderAreaGranularity)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateCommandPool", vkCreateCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyCommandPool", vkDestroyCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkResetCommandPool", vkResetCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkAllocateCommandBuffers", vkAllocateCommandBuffers)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkFreeCommandBuffers", vkFreeCommandBuffers)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkBeginCommandBuffer", vkBeginCommandBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEndCommandBuffer", vkEndCommandBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkResetCommandBuffer", vkResetCommandBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBindPipeline", vkCmdBindPipeline)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetViewport", vkCmdSetViewport)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetScissor", vkCmdSetScissor)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetLineWidth", vkCmdSetLineWidth)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetDepthBias", vkCmdSetDepthBias)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetBlendConstants", vkCmdSetBlendConstants)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetDepthBounds", vkCmdSetDepthBounds)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetStencilCompareMask", vkCmdSetStencilCompareMask)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetStencilWriteMask", vkCmdSetStencilWriteMask)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetStencilReference", vkCmdSetStencilReference)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBindDescriptorSets", vkCmdBindDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBindIndexBuffer", vkCmdBindIndexBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBindVertexBuffers", vkCmdBindVertexBuffers)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDraw", vkCmdDraw)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawIndexed", vkCmdDrawIndexed)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawIndirect", vkCmdDrawIndirect)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawIndexedIndirect", vkCmdDrawIndexedIndirect)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDispatch", vkCmdDispatch)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDispatchIndirect", vkCmdDispatchIndirect)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdCopyBuffer", vkCmdCopyBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdCopyImage", vkCmdCopyImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBlitImage", vkCmdBlitImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdCopyBufferToImage", vkCmdCopyBufferToImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdCopyImageToBuffer", vkCmdCopyImageToBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdUpdateBuffer", vkCmdUpdateBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdFillBuffer", vkCmdFillBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdClearColorImage", vkCmdClearColorImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdClearDepthStencilImage", vkCmdClearDepthStencilImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdClearAttachments", vkCmdClearAttachments)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdResolveImage", vkCmdResolveImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetEvent", vkCmdSetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdResetEvent", vkCmdResetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdWaitEvents", vkCmdWaitEvents)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdPipelineBarrier", vkCmdPipelineBarrier)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBeginQuery", vkCmdBeginQuery)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdEndQuery", vkCmdEndQuery)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdResetQueryPool", vkCmdResetQueryPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdWriteTimestamp", vkCmdWriteTimestamp)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdCopyQueryPoolResults", vkCmdCopyQueryPoolResults)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdPushConstants", vkCmdPushConstants)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBeginRenderPass", vkCmdBeginRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdNextSubpass", vkCmdNextSubpass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdEndRenderPass", vkCmdEndRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdExecuteCommands", vkCmdExecuteCommands)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumerateInstanceVersion", vkEnumerateInstanceVersion)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkBindBufferMemory2", vkBindBufferMemory2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkBindImageMemory2", vkBindImageMemory2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDeviceGroupPeerMemoryFeatures", vkGetDeviceGroupPeerMemoryFeatures)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetDeviceMask", vkCmdSetDeviceMask)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDispatchBase", vkCmdDispatchBase)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumeratePhysicalDeviceGroups", vkEnumeratePhysicalDeviceGroups)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetBufferMemoryRequirements2", vkGetBufferMemoryRequirements2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetImageSparseMemoryRequirements2", vkGetImageSparseMemoryRequirements2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFeatures2", vkGetPhysicalDeviceFeatures2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceProperties2", vkGetPhysicalDeviceProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFormatProperties2", vkGetPhysicalDeviceFormatProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceImageFormatProperties2", vkGetPhysicalDeviceImageFormatProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceQueueFamilyProperties2", vkGetPhysicalDeviceQueueFamilyProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceMemoryProperties2", vkGetPhysicalDeviceMemoryProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2", vkGetPhysicalDeviceSparseImageFormatProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkTrimCommandPool", vkTrimCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDeviceQueue2", vkGetDeviceQueue2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateSamplerYcbcrConversion", vkCreateSamplerYcbcrConversion)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroySamplerYcbcrConversion", vkDestroySamplerYcbcrConversion)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateDescriptorUpdateTemplate", vkCreateDescriptorUpdateTemplate)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyDescriptorUpdateTemplate", vkDestroyDescriptorUpdateTemplate)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkUpdateDescriptorSetWithTemplate", vkUpdateDescriptorSetWithTemplate)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalFenceProperties", vkGetPhysicalDeviceExternalFenceProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties", vkGetPhysicalDeviceExternalSemaphoreProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDescriptorSetLayoutSupport", vkGetDescriptorSetLayoutSupport)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetImageViewHandleNVX", vkGetImageViewHandleNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawIndirectCountAMD", vkCmdDrawIndirectCountAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawIndexedIndirectCountAMD", vkCmdDrawIndexedIndirectCountAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetShaderInfoAMD", vkGetShaderInfoAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", vkGetPhysicalDeviceExternalImageFormatPropertiesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdProcessCommandsNVX", vkCmdProcessCommandsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdReserveSpaceForCommandsNVX", vkCmdReserveSpaceForCommandsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateIndirectCommandsLayoutNVX", vkCreateIndirectCommandsLayoutNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyIndirectCommandsLayoutNVX", vkDestroyIndirectCommandsLayoutNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateObjectTableNVX", vkCreateObjectTableNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyObjectTableNVX", vkDestroyObjectTableNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkRegisterObjectsNVX", vkRegisterObjectsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkUnregisterObjectsNVX", vkUnregisterObjectsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetViewportWScalingNV", vkCmdSetViewportWScalingNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetRefreshCycleDurationGOOGLE", vkGetRefreshCycleDurationGOOGLE)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPastPresentationTimingGOOGLE", vkGetPastPresentationTimingGOOGLE)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBindShadingRateImageNV", vkCmdBindShadingRateImageNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetViewportShadingRatePaletteNV", vkCmdSetViewportShadingRatePaletteNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetCoarseSampleOrderNV", vkCmdSetCoarseSampleOrderNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateAccelerationStructureNV", vkCreateAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyAccelerationStructureNV", vkDestroyAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetAccelerationStructureMemoryRequirementsNV", vkGetAccelerationStructureMemoryRequirementsNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkBindAccelerationStructureMemoryNV", vkBindAccelerationStructureMemoryNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdBuildAccelerationStructureNV", vkCmdBuildAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdCopyAccelerationStructureNV", vkCmdCopyAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdTraceRaysNV", vkCmdTraceRaysNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateRayTracingPipelinesNV", vkCreateRayTracingPipelinesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetRayTracingShaderGroupHandlesNV", vkGetRayTracingShaderGroupHandlesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetAccelerationStructureHandleNV", vkGetAccelerationStructureHandleNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdWriteAccelerationStructuresPropertiesNV", vkCmdWriteAccelerationStructuresPropertiesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCompileDeferredNV", vkCompileDeferredNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdWriteBufferMarkerAMD", vkCmdWriteBufferMarkerAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawMeshTasksNV", vkCmdDrawMeshTasksNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawMeshTasksIndirectNV", vkCmdDrawMeshTasksIndirectNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdDrawMeshTasksIndirectCountNV", vkCmdDrawMeshTasksIndirectCountNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetExclusiveScissorNV", vkCmdSetExclusiveScissorNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetCheckpointNV", vkCmdSetCheckpointNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetQueueCheckpointDataNV", vkGetQueueCheckpointDataNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkInitializePerformanceApiINTEL", vkInitializePerformanceApiINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkUninitializePerformanceApiINTEL", vkUninitializePerformanceApiINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetPerformanceMarkerINTEL", vkCmdSetPerformanceMarkerINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetPerformanceStreamMarkerINTEL", vkCmdSetPerformanceStreamMarkerINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCmdSetPerformanceOverrideINTEL", vkCmdSetPerformanceOverrideINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkAcquirePerformanceConfigurationINTEL", vkAcquirePerformanceConfigurationINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkReleasePerformanceConfigurationINTEL", vkReleasePerformanceConfigurationINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkQueueSetPerformanceConfigurationINTEL", vkQueueSetPerformanceConfigurationINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkSetLocalDimmingAMD", vkSetLocalDimmingAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)) return VK_FALSE; + return VK_TRUE; +} + +VkBool32 vulkan_symbol_wrapper_load_core_instance_symbols(VkInstance instance) +{ + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkDestroyInstance", vkDestroyInstance)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumeratePhysicalDevices", vkEnumeratePhysicalDevices)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFeatures", vkGetPhysicalDeviceFeatures)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFormatProperties", vkGetPhysicalDeviceFormatProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceImageFormatProperties", vkGetPhysicalDeviceImageFormatProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceProperties", vkGetPhysicalDeviceProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceQueueFamilyProperties", vkGetPhysicalDeviceQueueFamilyProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceMemoryProperties", vkGetPhysicalDeviceMemoryProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetDeviceProcAddr", vkGetDeviceProcAddr)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkCreateDevice", vkCreateDevice)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumerateDeviceExtensionProperties", vkEnumerateDeviceExtensionProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumerateDeviceLayerProperties", vkEnumerateDeviceLayerProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceSparseImageFormatProperties", vkGetPhysicalDeviceSparseImageFormatProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumerateInstanceVersion", vkEnumerateInstanceVersion)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkEnumeratePhysicalDeviceGroups", vkEnumeratePhysicalDeviceGroups)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFeatures2", vkGetPhysicalDeviceFeatures2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceProperties2", vkGetPhysicalDeviceProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceFormatProperties2", vkGetPhysicalDeviceFormatProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceImageFormatProperties2", vkGetPhysicalDeviceImageFormatProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceQueueFamilyProperties2", vkGetPhysicalDeviceQueueFamilyProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceMemoryProperties2", vkGetPhysicalDeviceMemoryProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2", vkGetPhysicalDeviceSparseImageFormatProperties2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalFenceProperties", vkGetPhysicalDeviceExternalFenceProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties", vkGetPhysicalDeviceExternalSemaphoreProperties)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", vkGetPhysicalDeviceExternalImageFormatPropertiesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)) return VK_FALSE; + return VK_TRUE; +} + +VkBool32 vulkan_symbol_wrapper_load_core_device_symbols(VkDevice device) +{ + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyDevice", vkDestroyDevice)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetDeviceQueue", vkGetDeviceQueue)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkQueueSubmit", vkQueueSubmit)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkQueueWaitIdle", vkQueueWaitIdle)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDeviceWaitIdle", vkDeviceWaitIdle)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkAllocateMemory", vkAllocateMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkFreeMemory", vkFreeMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkMapMemory", vkMapMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkUnmapMemory", vkUnmapMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkFlushMappedMemoryRanges", vkFlushMappedMemoryRanges)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkInvalidateMappedMemoryRanges", vkInvalidateMappedMemoryRanges)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetDeviceMemoryCommitment", vkGetDeviceMemoryCommitment)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkBindBufferMemory", vkBindBufferMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkBindImageMemory", vkBindImageMemory)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetBufferMemoryRequirements", vkGetBufferMemoryRequirements)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetImageMemoryRequirements", vkGetImageMemoryRequirements)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetImageSparseMemoryRequirements", vkGetImageSparseMemoryRequirements)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkQueueBindSparse", vkQueueBindSparse)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateFence", vkCreateFence)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyFence", vkDestroyFence)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkResetFences", vkResetFences)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetFenceStatus", vkGetFenceStatus)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkWaitForFences", vkWaitForFences)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateSemaphore", vkCreateSemaphore)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroySemaphore", vkDestroySemaphore)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateEvent", vkCreateEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyEvent", vkDestroyEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetEventStatus", vkGetEventStatus)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkSetEvent", vkSetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkResetEvent", vkResetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateQueryPool", vkCreateQueryPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyQueryPool", vkDestroyQueryPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetQueryPoolResults", vkGetQueryPoolResults)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateBuffer", vkCreateBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyBuffer", vkDestroyBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateBufferView", vkCreateBufferView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyBufferView", vkDestroyBufferView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateImage", vkCreateImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyImage", vkDestroyImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetImageSubresourceLayout", vkGetImageSubresourceLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateImageView", vkCreateImageView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyImageView", vkDestroyImageView)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateShaderModule", vkCreateShaderModule)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyShaderModule", vkDestroyShaderModule)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreatePipelineCache", vkCreatePipelineCache)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyPipelineCache", vkDestroyPipelineCache)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetPipelineCacheData", vkGetPipelineCacheData)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkMergePipelineCaches", vkMergePipelineCaches)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateGraphicsPipelines", vkCreateGraphicsPipelines)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateComputePipelines", vkCreateComputePipelines)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyPipeline", vkDestroyPipeline)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreatePipelineLayout", vkCreatePipelineLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyPipelineLayout", vkDestroyPipelineLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateSampler", vkCreateSampler)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroySampler", vkDestroySampler)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateDescriptorSetLayout", vkCreateDescriptorSetLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyDescriptorSetLayout", vkDestroyDescriptorSetLayout)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateDescriptorPool", vkCreateDescriptorPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyDescriptorPool", vkDestroyDescriptorPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkResetDescriptorPool", vkResetDescriptorPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkAllocateDescriptorSets", vkAllocateDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkFreeDescriptorSets", vkFreeDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkUpdateDescriptorSets", vkUpdateDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateFramebuffer", vkCreateFramebuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyFramebuffer", vkDestroyFramebuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateRenderPass", vkCreateRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyRenderPass", vkDestroyRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetRenderAreaGranularity", vkGetRenderAreaGranularity)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateCommandPool", vkCreateCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyCommandPool", vkDestroyCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkResetCommandPool", vkResetCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkAllocateCommandBuffers", vkAllocateCommandBuffers)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkFreeCommandBuffers", vkFreeCommandBuffers)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkBeginCommandBuffer", vkBeginCommandBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkEndCommandBuffer", vkEndCommandBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkResetCommandBuffer", vkResetCommandBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBindPipeline", vkCmdBindPipeline)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetViewport", vkCmdSetViewport)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetScissor", vkCmdSetScissor)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetLineWidth", vkCmdSetLineWidth)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetDepthBias", vkCmdSetDepthBias)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetBlendConstants", vkCmdSetBlendConstants)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetDepthBounds", vkCmdSetDepthBounds)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetStencilCompareMask", vkCmdSetStencilCompareMask)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetStencilWriteMask", vkCmdSetStencilWriteMask)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetStencilReference", vkCmdSetStencilReference)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBindDescriptorSets", vkCmdBindDescriptorSets)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBindIndexBuffer", vkCmdBindIndexBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBindVertexBuffers", vkCmdBindVertexBuffers)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDraw", vkCmdDraw)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawIndexed", vkCmdDrawIndexed)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawIndirect", vkCmdDrawIndirect)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawIndexedIndirect", vkCmdDrawIndexedIndirect)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDispatch", vkCmdDispatch)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDispatchIndirect", vkCmdDispatchIndirect)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdCopyBuffer", vkCmdCopyBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdCopyImage", vkCmdCopyImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBlitImage", vkCmdBlitImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdCopyBufferToImage", vkCmdCopyBufferToImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdCopyImageToBuffer", vkCmdCopyImageToBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdUpdateBuffer", vkCmdUpdateBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdFillBuffer", vkCmdFillBuffer)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdClearColorImage", vkCmdClearColorImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdClearDepthStencilImage", vkCmdClearDepthStencilImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdClearAttachments", vkCmdClearAttachments)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdResolveImage", vkCmdResolveImage)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetEvent", vkCmdSetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdResetEvent", vkCmdResetEvent)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdWaitEvents", vkCmdWaitEvents)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdPipelineBarrier", vkCmdPipelineBarrier)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBeginQuery", vkCmdBeginQuery)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdEndQuery", vkCmdEndQuery)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdResetQueryPool", vkCmdResetQueryPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdWriteTimestamp", vkCmdWriteTimestamp)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdCopyQueryPoolResults", vkCmdCopyQueryPoolResults)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdPushConstants", vkCmdPushConstants)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBeginRenderPass", vkCmdBeginRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdNextSubpass", vkCmdNextSubpass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdEndRenderPass", vkCmdEndRenderPass)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdExecuteCommands", vkCmdExecuteCommands)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkBindBufferMemory2", vkBindBufferMemory2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkBindImageMemory2", vkBindImageMemory2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetDeviceGroupPeerMemoryFeatures", vkGetDeviceGroupPeerMemoryFeatures)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetDeviceMask", vkCmdSetDeviceMask)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDispatchBase", vkCmdDispatchBase)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetBufferMemoryRequirements2", vkGetBufferMemoryRequirements2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetImageSparseMemoryRequirements2", vkGetImageSparseMemoryRequirements2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkTrimCommandPool", vkTrimCommandPool)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetDeviceQueue2", vkGetDeviceQueue2)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateSamplerYcbcrConversion", vkCreateSamplerYcbcrConversion)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroySamplerYcbcrConversion", vkDestroySamplerYcbcrConversion)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateDescriptorUpdateTemplate", vkCreateDescriptorUpdateTemplate)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyDescriptorUpdateTemplate", vkDestroyDescriptorUpdateTemplate)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkUpdateDescriptorSetWithTemplate", vkUpdateDescriptorSetWithTemplate)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetDescriptorSetLayoutSupport", vkGetDescriptorSetLayoutSupport)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetImageViewHandleNVX", vkGetImageViewHandleNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawIndirectCountAMD", vkCmdDrawIndirectCountAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawIndexedIndirectCountAMD", vkCmdDrawIndexedIndirectCountAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetShaderInfoAMD", vkGetShaderInfoAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdProcessCommandsNVX", vkCmdProcessCommandsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdReserveSpaceForCommandsNVX", vkCmdReserveSpaceForCommandsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateIndirectCommandsLayoutNVX", vkCreateIndirectCommandsLayoutNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyIndirectCommandsLayoutNVX", vkDestroyIndirectCommandsLayoutNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateObjectTableNVX", vkCreateObjectTableNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyObjectTableNVX", vkDestroyObjectTableNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkRegisterObjectsNVX", vkRegisterObjectsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkUnregisterObjectsNVX", vkUnregisterObjectsNVX)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetViewportWScalingNV", vkCmdSetViewportWScalingNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetRefreshCycleDurationGOOGLE", vkGetRefreshCycleDurationGOOGLE)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetPastPresentationTimingGOOGLE", vkGetPastPresentationTimingGOOGLE)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBindShadingRateImageNV", vkCmdBindShadingRateImageNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetViewportShadingRatePaletteNV", vkCmdSetViewportShadingRatePaletteNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetCoarseSampleOrderNV", vkCmdSetCoarseSampleOrderNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateAccelerationStructureNV", vkCreateAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkDestroyAccelerationStructureNV", vkDestroyAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetAccelerationStructureMemoryRequirementsNV", vkGetAccelerationStructureMemoryRequirementsNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkBindAccelerationStructureMemoryNV", vkBindAccelerationStructureMemoryNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdBuildAccelerationStructureNV", vkCmdBuildAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdCopyAccelerationStructureNV", vkCmdCopyAccelerationStructureNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdTraceRaysNV", vkCmdTraceRaysNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCreateRayTracingPipelinesNV", vkCreateRayTracingPipelinesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetRayTracingShaderGroupHandlesNV", vkGetRayTracingShaderGroupHandlesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetAccelerationStructureHandleNV", vkGetAccelerationStructureHandleNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdWriteAccelerationStructuresPropertiesNV", vkCmdWriteAccelerationStructuresPropertiesNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCompileDeferredNV", vkCompileDeferredNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdWriteBufferMarkerAMD", vkCmdWriteBufferMarkerAMD)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawMeshTasksNV", vkCmdDrawMeshTasksNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawMeshTasksIndirectNV", vkCmdDrawMeshTasksIndirectNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdDrawMeshTasksIndirectCountNV", vkCmdDrawMeshTasksIndirectCountNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetExclusiveScissorNV", vkCmdSetExclusiveScissorNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetCheckpointNV", vkCmdSetCheckpointNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetQueueCheckpointDataNV", vkGetQueueCheckpointDataNV)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkInitializePerformanceApiINTEL", vkInitializePerformanceApiINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkUninitializePerformanceApiINTEL", vkUninitializePerformanceApiINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetPerformanceMarkerINTEL", vkCmdSetPerformanceMarkerINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetPerformanceStreamMarkerINTEL", vkCmdSetPerformanceStreamMarkerINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkCmdSetPerformanceOverrideINTEL", vkCmdSetPerformanceOverrideINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkAcquirePerformanceConfigurationINTEL", vkAcquirePerformanceConfigurationINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkReleasePerformanceConfigurationINTEL", vkReleasePerformanceConfigurationINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkQueueSetPerformanceConfigurationINTEL", vkQueueSetPerformanceConfigurationINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL)) return VK_FALSE; + if (!VULKAN_SYMBOL_WRAPPER_LOAD_DEVICE_SYMBOL(device, "vkSetLocalDimmingAMD", vkSetLocalDimmingAMD)) return VK_FALSE; + return VK_TRUE; +} diff --git a/core/rend/dx9/d3d_overlay.cpp b/core/rend/dx9/d3d_overlay.cpp index d68001539..8bb51fc48 100644 --- a/core/rend/dx9/d3d_overlay.cpp +++ b/core/rend/dx9/d3d_overlay.cpp @@ -118,7 +118,7 @@ void D3DOverlay::draw(u32 width, u32 height, bool vmu, bool crosshair) float x, y; std::tie(x, y) = getCrosshairPosition(i); - float halfWidth = XHAIR_WIDTH / 2.f; + float halfWidth = XHAIR_WIDTH * gui_get_scaling() / 2.f; RECT rect { (long) (x - halfWidth), (long) (y - halfWidth), (long) (x + halfWidth), (long) (y + halfWidth) }; D3DCOLOR color = (config::CrosshairColor[i] & 0xFF00FF00) | ((config::CrosshairColor[i] >> 16) & 0xFF) diff --git a/core/rend/gui.cpp b/core/rend/gui.cpp index 4d1bef72a..77db80bcd 100644 --- a/core/rend/gui.cpp +++ b/core/rend/gui.cpp @@ -2377,9 +2377,9 @@ static void displayCrosshairs() ImVec2 pos; std::tie(pos.x, pos.y) = getCrosshairPosition(i); - pos.x -= XHAIR_WIDTH / 2.f; - pos.y += XHAIR_WIDTH / 2.f; - ImVec2 pos_b(pos.x + XHAIR_WIDTH, pos.y - XHAIR_HEIGHT); + pos.x -= (XHAIR_WIDTH * scaling) / 2.f; + pos.y += (XHAIR_WIDTH * scaling) / 2.f; + ImVec2 pos_b(pos.x + XHAIR_WIDTH * scaling, pos.y - XHAIR_HEIGHT * scaling); ImGui::GetWindowDrawList()->AddImage(crosshairTexId, pos, pos_b, ImVec2(0, 1), ImVec2(1, 0), config::CrosshairColor[i]); } diff --git a/core/rend/gui.h b/core/rend/gui.h index deb396b7e..4f4a9dadf 100644 --- a/core/rend/gui.h +++ b/core/rend/gui.h @@ -66,20 +66,3 @@ static inline bool gui_is_content_browser() static inline float gui_get_scaling() { return scaling; } - -#define XHAIR_WIDTH (40 * scaling) -#define XHAIR_HEIGHT (40 * scaling) -static inline bool crosshairsNeeded() -{ - if (config::CrosshairColor[0] == 0 && config::CrosshairColor[1] == 0 - && config::CrosshairColor[2] == 0 && config::CrosshairColor[3] == 0) - return false; - if (settings.platform.system != DC_PLATFORM_DREAMCAST - && settings.input.JammaSetup != JVS::LightGun - && settings.input.JammaSetup != JVS::LightGunAsAnalog - && settings.input.JammaSetup != JVS::Mazan) - // not a lightgun game - return false; - return true; -} -std::pair getCrosshairPosition(int playerNum); diff --git a/core/rend/osd.h b/core/rend/osd.h index e1a1a446c..f2762f6c3 100644 --- a/core/rend/osd.h +++ b/core/rend/osd.h @@ -17,6 +17,7 @@ #pragma once #include "types.h" +#include "cfg/option.h" #include #define VJOY_VISIBLE 14 @@ -45,3 +46,21 @@ void push_vmu_screen(int bus_id, int bus_port, u8* buffer); // Crosshair const u32 *getCrosshairTextureData(); +std::pair getCrosshairPosition(int playerNum); + +constexpr int XHAIR_WIDTH = 40; +constexpr int XHAIR_HEIGHT = 40; + +static inline bool crosshairsNeeded() +{ + if (config::CrosshairColor[0] == 0 && config::CrosshairColor[1] == 0 + && config::CrosshairColor[2] == 0 && config::CrosshairColor[3] == 0) + return false; + if (settings.platform.system != DC_PLATFORM_DREAMCAST + && settings.input.JammaSetup != JVS::LightGun + && settings.input.JammaSetup != JVS::LightGunAsAnalog + && settings.input.JammaSetup != JVS::Mazan) + // not a lightgun game + return false; + return true; +} diff --git a/core/rend/vulkan/commandpool.h b/core/rend/vulkan/commandpool.h index 07f309577..6e183dd0b 100644 --- a/core/rend/vulkan/commandpool.h +++ b/core/rend/vulkan/commandpool.h @@ -59,8 +59,7 @@ public: void EndFrame() { std::vector commandBuffers = vk::uniqueToRaw(inFlightBuffers[index]); - VulkanContext::Instance()->GetGraphicsQueue().submit( - vk::SubmitInfo(0, nullptr, nullptr, commandBuffers.size(), commandBuffers.data()), *fences[index]); + VulkanContext::Instance()->SubmitCommandBuffers(commandBuffers.size(), commandBuffers.data(), *fences[index]); } void BeginFrame() diff --git a/core/rend/vulkan/drawer.h b/core/rend/vulkan/drawer.h index a09f3ba06..b95092906 100644 --- a/core/rend/vulkan/drawer.h +++ b/core/rend/vulkan/drawer.h @@ -106,6 +106,7 @@ public: virtual ~Drawer() = default; bool Draw(const Texture *fogTexture, const Texture *paletteTexture); virtual void EndRenderPass() { renderPass++; } + vk::CommandBuffer GetCurrentCommandBuffer() const { return currentCommandBuffer; } protected: virtual size_t GetSwapChainSize() { return GetContext()->GetSwapChainSize(); } @@ -194,13 +195,15 @@ class ScreenDrawer : public Drawer { public: void Init(SamplerManager *samplerManager, ShaderManager *shaderManager, const vk::Extent2D& viewport); + vk::RenderPass GetRenderPass() const { return *renderPassClear; } void EndRenderPass() override; bool PresentFrame() { if (!frameRendered) return false; frameRendered = false; - GetContext()->PresentFrame(colorAttachments[GetCurrentImage()]->GetImageView(), viewport); + GetContext()->PresentFrame(colorAttachments[GetCurrentImage()]->GetImage(), + colorAttachments[GetCurrentImage()]->GetImageView(), viewport); NewImage(); return true; diff --git a/core/rend/vulkan/oit/oit_drawer.h b/core/rend/vulkan/oit/oit_drawer.h index b34c13ec4..14af4e8fc 100644 --- a/core/rend/vulkan/oit/oit_drawer.h +++ b/core/rend/vulkan/oit/oit_drawer.h @@ -168,7 +168,7 @@ public: OITDrawer::Init(samplerManager, screenPipelineManager.get(), oitBuffers); MakeFramebuffers(viewport); - GetContext()->PresentFrame(vk::ImageView(), viewport); + GetContext()->PresentFrame(vk::Image(), vk::ImageView(), viewport); } void Term() { @@ -194,11 +194,14 @@ public: if (!frameRendered) return false; frameRendered = false; - GetContext()->PresentFrame(finalColorAttachments[GetCurrentImage()]->GetImageView(), viewport.extent); + GetContext()->PresentFrame(finalColorAttachments[GetCurrentImage()]->GetImage(), + finalColorAttachments[GetCurrentImage()]->GetImageView(), viewport.extent); NewImage(); return true; } + vk::RenderPass GetRenderPass() const { return screenPipelineManager->GetRenderPass(false, true); } + vk::CommandBuffer GetCurrentCommandBuffer() const { return currentCommandBuffer; } protected: vk::Framebuffer GetFinalFramebuffer() const override { return *framebuffers[GetCurrentImage()]; } diff --git a/core/rend/vulkan/oit/oit_renderer.cpp b/core/rend/vulkan/oit/oit_renderer.cpp index 8ecca2d89..927904e6a 100644 --- a/core/rend/vulkan/oit/oit_renderer.cpp +++ b/core/rend/vulkan/oit/oit_renderer.cpp @@ -29,16 +29,16 @@ class OITVulkanRenderer final : public BaseVulkanRenderer public: bool Init() override { - DEBUG_LOG(RENDERER, "OITVulkanRenderer::Init"); + NOTICE_LOG(RENDERER, "OITVulkanRenderer::Init"); try { - BaseVulkanRenderer::Init(); - oitBuffers.Init(viewport.width, viewport.height); textureDrawer.Init(&samplerManager, &oitShaderManager, &textureCache, &oitBuffers); textureDrawer.SetCommandPool(&texCommandPool); screenDrawer.Init(&samplerManager, &oitShaderManager, &oitBuffers, viewport); screenDrawer.SetCommandPool(&texCommandPool); + BaseInit(screenDrawer.GetRenderPass(), 2); + return true; } @@ -77,6 +77,10 @@ public: drawer = &screenDrawer; drawer->Draw(fogTexture.get(), paletteTexture.get()); +#ifdef LIBRETRO + if (!pvrrc.isRTT) + overlay->Draw(screenDrawer.GetCurrentCommandBuffer(), viewport, (int)config::RenderResolution / 480.f, true, true); +#endif drawer->EndFrame(); diff --git a/core/rend/vulkan/overlay.cpp b/core/rend/vulkan/overlay.cpp index 776796c3f..bbd529740 100644 --- a/core/rend/vulkan/overlay.cpp +++ b/core/rend/vulkan/overlay.cpp @@ -19,7 +19,6 @@ along with Flycast. If not, see . */ #include "texture.h" -#include "rend/gui.h" #include "hw/maple/maple_devs.h" #include "overlay.h" #include "cfg/option.h" @@ -41,15 +40,8 @@ std::unique_ptr VulkanOverlay::createTexture(vk::CommandBuffer commandB return texture; } -vk::CommandBuffer VulkanOverlay::Prepare(vk::CommandPool commandPool, bool vmu, bool crosshair) +void VulkanOverlay::Prepare(vk::CommandBuffer cmdBuffer, bool vmu, bool crosshair) { - VulkanContext *context = VulkanContext::Instance(); - commandBuffers.resize(context->GetSwapChainSize()); - commandBuffers[context->GetCurrentImageIndex()] = std::move( - VulkanContext::Instance()->GetDevice().allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo(commandPool, vk::CommandBufferLevel::ePrimary, 1)) - .front()); - vk::CommandBuffer cmdBuffer = *commandBuffers[context->GetCurrentImageIndex()]; - cmdBuffer.begin(vk::CommandBufferBeginInfo(vk::CommandBufferUsageFlagBits::eOneTimeSubmit)); if (vmu) { for (size_t i = 0; i < vmuTextures.size(); i++) @@ -72,15 +64,25 @@ vk::CommandBuffer VulkanOverlay::Prepare(vk::CommandPool commandPool, bool vmu, const u32* texData = getCrosshairTextureData(); xhairTexture = createTexture(cmdBuffer, 16, 16, (u8*)texData); } +} + +vk::CommandBuffer VulkanOverlay::Prepare(vk::CommandPool commandPool, bool vmu, bool crosshair) +{ + VulkanContext *context = VulkanContext::Instance(); + commandBuffers.resize(context->GetSwapChainSize()); + commandBuffers[context->GetCurrentImageIndex()] = std::move( + VulkanContext::Instance()->GetDevice().allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo(commandPool, vk::CommandBufferLevel::ePrimary, 1)) + .front()); + vk::CommandBuffer cmdBuffer = *commandBuffers[context->GetCurrentImageIndex()]; + cmdBuffer.begin(vk::CommandBufferBeginInfo(vk::CommandBufferUsageFlagBits::eOneTimeSubmit)); + Prepare(cmdBuffer, vmu, crosshair); cmdBuffer.end(); return cmdBuffer; } -void VulkanOverlay::Draw(vk::Extent2D viewport, float scaling, bool vmu, bool crosshair) +void VulkanOverlay::Draw(vk::CommandBuffer commandBuffer, vk::Extent2D viewport, float scaling, bool vmu, bool crosshair) { - VulkanContext *context = VulkanContext::Instance(); - vk::CommandBuffer commandBuffer = context->GetCurrentCommandBuffer(); QuadVertex vtx[] = { { { -1.f, -1.f, 0.f }, { 0.f, 1.f } }, { { 1.f, -1.f, 0.f }, { 1.f, 1.f } }, @@ -139,12 +141,14 @@ void VulkanOverlay::Draw(vk::Extent2D viewport, float scaling, bool vmu, bool cr float x, y; std::tie(x, y) = getCrosshairPosition(i); - x -= XHAIR_WIDTH / 2; - y -= XHAIR_HEIGHT / 2; - vk::Viewport viewport(x, y, XHAIR_WIDTH, XHAIR_HEIGHT); + float w = XHAIR_WIDTH * scaling; + float h = XHAIR_HEIGHT * scaling; + x -= w / 2; + y -= h / 2; + vk::Viewport viewport(x, y, w, h); commandBuffer.setViewport(0, 1, &viewport); commandBuffer.setScissor(0, vk::Rect2D(vk::Offset2D(std::max(0.f, x), std::max(0.f, y)), - vk::Extent2D(XHAIR_WIDTH, XHAIR_HEIGHT))); + vk::Extent2D(w, h))); u32 color = config::CrosshairColor[i]; float xhairColor[4] { (color & 0xff) / 255.f, diff --git a/core/rend/vulkan/overlay.h b/core/rend/vulkan/overlay.h index d5c01ffb7..da4976877 100644 --- a/core/rend/vulkan/overlay.h +++ b/core/rend/vulkan/overlay.h @@ -56,7 +56,8 @@ public: } vk::CommandBuffer Prepare(vk::CommandPool commandPool, bool vmu, bool crosshair); - void Draw(vk::Extent2D viewport, float scaling, bool vmu, bool crosshair); + void Prepare(vk::CommandBuffer commandBuffer, bool vmu, bool crosshair); + void Draw(vk::CommandBuffer commandBuffer, vk::Extent2D viewport, float scaling, bool vmu, bool crosshair); private: std::unique_ptr createTexture(vk::CommandBuffer commandBuffer, int width, int height, u8 *data); diff --git a/core/rend/vulkan/vk_context_lr.cpp b/core/rend/vulkan/vk_context_lr.cpp new file mode 100644 index 000000000..15cd3225d --- /dev/null +++ b/core/rend/vulkan/vk_context_lr.cpp @@ -0,0 +1,324 @@ +/* + Created on: Oct 2, 2019 + + Copyright 2019 flyinghead + + This file is part of Flycast. + + Flycast is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + Flycast is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Flycast. If not, see . + */ +#include "vulkan_context.h" +#include "hw/pvr/Renderer_if.h" +#include "compiler.h" +#include "oslib/oslib.h" + +VulkanContext *VulkanContext::contextInstance; + +const VkApplicationInfo* VkGetApplicationInfo() +{ + // apiVersion is the maximum vulkan version supported by the app + static vk::ApplicationInfo applicationInfo("Flycast", 1, "Flycast", 1, VK_API_VERSION_1_1); + return &(VkApplicationInfo&)applicationInfo; +} + +bool VkCreateDevice(retro_vulkan_context* context, VkInstance instance, VkPhysicalDevice gpu, + VkSurfaceKHR surface, PFN_vkGetInstanceProcAddr get_instance_proc_addr, + const char** required_device_extensions, + unsigned num_required_device_extensions, + const char** required_device_layers, unsigned num_required_device_layers, + const VkPhysicalDeviceFeatures* required_features) +{ + vulkan_symbol_wrapper_init(get_instance_proc_addr); + vulkan_symbol_wrapper_load_global_symbols(); + vulkan_symbol_wrapper_load_core_symbols(instance); + VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_EXTENSION_SYMBOL(instance, vkGetPhysicalDeviceSurfaceSupportKHR); + + vk::PhysicalDevice physicalDevice(gpu); + if (gpu == VK_NULL_HANDLE) + { + // Choose a discrete gpu if there's one, otherwise just pick the first one + verify(instance != VK_NULL_HANDLE); + vk::Instance vkinstance(instance); + const auto devices = vkinstance.enumeratePhysicalDevices(); + for (const auto& phyDev : devices) + { + vk::PhysicalDeviceProperties props; + phyDev.getProperties(&props); + if (props.deviceType == vk::PhysicalDeviceType::eDiscreteGpu) + { + physicalDevice = phyDev; + break; + } + } + if (!physicalDevice) + physicalDevice = vkinstance.enumeratePhysicalDevices().front(); + } + context->gpu = (VkPhysicalDevice)physicalDevice; + std::vector queueFamilyProperties = physicalDevice.getQueueFamilyProperties(); + + // get the first index into queueFamilyProperties which supports graphics and compute + context->queue_family_index = (u32)std::distance(queueFamilyProperties.begin(), + std::find_if(queueFamilyProperties.begin(), queueFamilyProperties.end(), + [](vk::QueueFamilyProperties const& qfp) { return (qfp.queueFlags & (vk::QueueFlagBits::eGraphics | vk::QueueFlagBits::eCompute)) + == (vk::QueueFlagBits::eGraphics | vk::QueueFlagBits::eCompute); })); + verify(context->queue_family_index < queueFamilyProperties.size()); + + if (surface != VK_NULL_HANDLE) + { + // determine a queue family index that supports present + // first check if the queue_family_index is good enough + vk::SurfaceKHR vksurface(surface); + context->presentation_queue_family_index = physicalDevice.getSurfaceSupportKHR(context->queue_family_index, vksurface) ? context->queue_family_index : queueFamilyProperties.size(); + if (context->presentation_queue_family_index == queueFamilyProperties.size()) + { + // the queue_family_index doesn't support present -> look for an other family index that supports both graphics, compute and present + for (size_t i = 0; i < queueFamilyProperties.size(); i++) + { + if ((queueFamilyProperties[i].queueFlags & (vk::QueueFlagBits::eGraphics | vk::QueueFlagBits::eCompute)) == (vk::QueueFlagBits::eGraphics | vk::QueueFlagBits::eCompute) + && physicalDevice.getSurfaceSupportKHR((u32)i, vksurface)) + { + context->queue_family_index = (u32)i; + context->presentation_queue_family_index = (u32)i; + break; + } + } + if (context->presentation_queue_family_index == queueFamilyProperties.size()) + { + // there's nothing like a single family index that supports both graphics/compute and present -> look for an other family index that supports present + DEBUG_LOG(RENDERER, "Using separate Graphics and Present queue families"); + for (size_t i = 0; i < queueFamilyProperties.size(); i++) + { + if (physicalDevice.getSurfaceSupportKHR((u32)i, vksurface)) + { + context->presentation_queue_family_index = (u32)i; + break; + } + } + } + } + if (context->queue_family_index == queueFamilyProperties.size() || context->presentation_queue_family_index == queueFamilyProperties.size()) + { + ERROR_LOG(RENDERER, "Could not find a queue for graphics or present"); + return false; + } + if (context->queue_family_index == context->presentation_queue_family_index) + DEBUG_LOG(RENDERER, "Using Graphics+Present queue family"); + else + DEBUG_LOG(RENDERER, "Using distinct Graphics and Present queue families"); + } + + vk::PhysicalDeviceFeatures supportedFeatures; + physicalDevice.getFeatures(&supportedFeatures); + bool fragmentStoresAndAtomics = supportedFeatures.fragmentStoresAndAtomics; + VulkanContext::Instance()->samplerAnisotropy = supportedFeatures.samplerAnisotropy; + + // Enable VK_KHR_dedicated_allocation if available + bool getMemReq2Supported = false; + VulkanContext::Instance()->dedicatedAllocationSupported = false; + std::vector deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; + for (int i = 0; i < num_required_device_extensions; i++) + deviceExtensions.push_back(required_device_extensions[i]); + for (const auto& property : physicalDevice.enumerateDeviceExtensionProperties()) + { + if (!strcmp(property.extensionName, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME)) + { + deviceExtensions.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); + getMemReq2Supported = true; + } + else if (!strcmp(property.extensionName, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME)) + { + deviceExtensions.push_back(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); + VulkanContext::Instance()->dedicatedAllocationSupported = true; + } + } + VulkanContext::Instance()->dedicatedAllocationSupported &= getMemReq2Supported; + + // create a Device + float queuePriority = 1.0f; + vk::DeviceQueueCreateInfo deviceQueueCreateInfos[] = { + vk::DeviceQueueCreateInfo(vk::DeviceQueueCreateFlags(), context->queue_family_index, 1, &queuePriority), + vk::DeviceQueueCreateInfo(vk::DeviceQueueCreateFlags(), context->presentation_queue_family_index, 1, &queuePriority), + }; + vk::PhysicalDeviceFeatures features(*required_features); + if (fragmentStoresAndAtomics) + features.fragmentStoresAndAtomics = true; + if (VulkanContext::Instance()->samplerAnisotropy) + features.samplerAnisotropy = true; + vk::Device device = physicalDevice.createDevice(vk::DeviceCreateInfo(vk::DeviceCreateFlags(), + context->queue_family_index == context->presentation_queue_family_index ? 1 : 2, deviceQueueCreateInfos, + num_required_device_layers, required_device_layers, deviceExtensions.size(), &deviceExtensions[0], &features)); + context->device = (VkDevice)device; + vulkan_symbol_wrapper_load_core_device_symbols(context->device); + + // Queues + context->queue = (VkQueue)device.getQueue(context->queue_family_index, 0); + context->presentation_queue = (VkQueue)device.getQueue(context->presentation_queue_family_index, 0); + + return true; +} + +bool VulkanContext::Init(retro_hw_render_interface_vulkan *retro_render_if) +{ + if (retro_render_if->interface_type != RETRO_HW_RENDER_INTERFACE_VULKAN + || retro_render_if->interface_version != RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION) + return false; + this->retro_render_if = retro_render_if; + + instance = vk::Instance(retro_render_if->instance); + physicalDevice = vk::PhysicalDevice(retro_render_if->gpu); + device = vk::Device(retro_render_if->device); + queue = vk::Queue(retro_render_if->queue); + + vk::PhysicalDeviceProperties *properties; + static vk::PhysicalDeviceProperties props; + physicalDevice.getProperties(&props); + + NOTICE_LOG(RENDERER, "GPU Supports Vulkan API: %u.%u.%u", + VK_VERSION_MAJOR(props.apiVersion), + VK_VERSION_MINOR(props.apiVersion), + VK_VERSION_PATCH(props.apiVersion)); + if (VK_VERSION_MINOR(props.apiVersion) >= 1 && ::vkGetPhysicalDeviceFormatProperties2 != nullptr) + { + NOTICE_LOG(RENDERER, "GPU Supports vkGetPhysicalDeviceProperties2"); + static vk::PhysicalDeviceProperties2 properties2; + vk::PhysicalDeviceMaintenance3Properties properties3; + properties2.pNext = &properties3; + physicalDevice.getProperties2(&properties2); + properties = &properties2.properties; + maxMemoryAllocationSize = properties3.maxMemoryAllocationSize; + } + else + { + properties = &props; + maxMemoryAllocationSize = 0xFFFFFFFFu; + } + uniformBufferAlignment = properties->limits.minUniformBufferOffsetAlignment; + storageBufferAlignment = properties->limits.minStorageBufferOffsetAlignment; + maxStorageBufferRange = properties->limits.maxStorageBufferRange; + maxSamplerAnisotropy = properties->limits.maxSamplerAnisotropy; + vendorID = properties->vendorID; + + vk::FormatProperties formatProperties = physicalDevice.getFormatProperties(vk::Format::eR5G5B5A1UnormPack16); + if ((formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) + && (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eBlitDst) + && (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eBlitSrc)) + optimalTilingSupported1555 = true; + else + NOTICE_LOG(RENDERER, "eR5G5B5A1UnormPack16 not supported for optimal tiling"); + formatProperties = physicalDevice.getFormatProperties(vk::Format::eR5G6B5UnormPack16); + if ((formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) + && (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eBlitDst) + && (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eBlitSrc)) + optimalTilingSupported565 = true; + else + NOTICE_LOG(RENDERER, "eR5G6B5UnormPack16 not supported for optimal tiling"); + formatProperties = physicalDevice.getFormatProperties(vk::Format::eR4G4B4A4UnormPack16); + if ((formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) + && (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eBlitDst) + && (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eBlitSrc)) + optimalTilingSupported4444 = true; + else + NOTICE_LOG(RENDERER, "eR4G4B4A4UnormPack16 not supported for optimal tiling"); + + ShaderCompiler::Init(); + + // Descriptor pool + vk::DescriptorPoolSize pool_sizes[] = + { + { vk::DescriptorType::eSampler, 2 }, + { vk::DescriptorType::eCombinedImageSampler, 4000 }, + { vk::DescriptorType::eSampledImage, 2 }, + { vk::DescriptorType::eStorageImage, 12 }, + { vk::DescriptorType::eUniformTexelBuffer, 2 }, + { vk::DescriptorType::eStorageTexelBuffer, 2 }, + { vk::DescriptorType::eUniformBuffer, 36 }, + { vk::DescriptorType::eStorageBuffer, 36 }, + { vk::DescriptorType::eUniformBufferDynamic, 2 }, + { vk::DescriptorType::eStorageBufferDynamic, 2 }, + { vk::DescriptorType::eInputAttachment, 36 } + }; + descriptorPool = device.createDescriptorPoolUnique(vk::DescriptorPoolCreateInfo(vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet, + 10000, ARRAY_SIZE(pool_sizes), pool_sizes)); + + std::string cachePath = hostfs::getVulkanCachePath(); + FILE *f = fopen(cachePath.c_str(), "rb"); + if (f == nullptr) + pipelineCache = device.createPipelineCacheUnique(vk::PipelineCacheCreateInfo()); + else + { + fseek(f, 0, SEEK_END); + size_t cacheSize = ftell(f); + fseek(f, 0, SEEK_SET); + u8 *cacheData = new u8[cacheSize]; + if (fread(cacheData, 1, cacheSize, f) != cacheSize) + cacheSize = 0; + fclose(f); + pipelineCache = device.createPipelineCacheUnique(vk::PipelineCacheCreateInfo(vk::PipelineCacheCreateFlags(), cacheSize, cacheData)); + delete [] cacheData; + INFO_LOG(RENDERER, "Vulkan pipeline cache loaded from %s: %zd bytes", cachePath.c_str(), cacheSize); + } + allocator.Init(physicalDevice, device); + depthFormat = findDepthFormat(physicalDevice); + + retro_image.image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + retro_image.create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + retro_image.create_info.pNext = nullptr; + retro_image.create_info.format = (VkFormat)colorFormat; + retro_image.create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; + retro_image.create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; + retro_image.create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; + retro_image.create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; + retro_image.create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; + retro_image.create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + retro_image.create_info.subresourceRange.baseArrayLayer = 0; + retro_image.create_info.subresourceRange.layerCount = 1; + retro_image.create_info.subresourceRange.baseMipLevel = 0; + retro_image.create_info.subresourceRange.levelCount = 1; + retro_image.create_info.flags = 0; + + return true; +} + +void VulkanContext::PresentFrame(vk::Image image, vk::ImageView imageView, const vk::Extent2D& extent) +{ + retro_image.image_view = (VkImageView)imageView; + retro_image.create_info.image = (VkImage)image; + retro_render_if->set_image(retro_render_if->handle, &retro_image, 0, nullptr, VK_QUEUE_FAMILY_IGNORED); +} + +void VulkanContext::Term() +{ + if (device) + { + device.waitIdle(); + if (pipelineCache) + { + std::vector cacheData = device.getPipelineCacheData(*pipelineCache); + if (!cacheData.empty()) + { + std::string cachePath = hostfs::getVulkanCachePath(); + FILE *f = fopen(cachePath.c_str(), "wb"); + if (f != nullptr) + { + (void)fwrite(&cacheData[0], 1, cacheData.size(), f); + fclose(f); + } + } + } + } + ShaderCompiler::Term(); + descriptorPool.reset(); + allocator.Term(); + pipelineCache.reset(); +} diff --git a/core/rend/vulkan/vk_context_lr.h b/core/rend/vulkan/vk_context_lr.h new file mode 100644 index 000000000..d01f16b41 --- /dev/null +++ b/core/rend/vulkan/vk_context_lr.h @@ -0,0 +1,136 @@ +/* + Created on: Nov 29, 2019 + + Copyright 2019 flyinghead + + This file is part of Flycast. + + Flycast is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + Flycast is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Flycast. If not, see . +*/ +#pragma once +#include "vulkan.h" +#include "vmallocator.h" +#include "quad.h" +#include "rend/TexCache.h" +#include "libretro_vulkan.h" + +extern int screen_width, screen_height; +static vk::Format findDepthFormat(vk::PhysicalDevice physicalDevice); + +class VulkanContext +{ +public: + VulkanContext() { verify(contextInstance == nullptr); contextInstance = this; } + ~VulkanContext() { verify(contextInstance == this); contextInstance = nullptr; } + + bool Init(retro_hw_render_interface_vulkan *render_if); + void Term(); + + u32 GetGraphicsQueueFamilyIndex() const { return retro_render_if->queue_index; } + void SetWindowSize(u32 width, u32 height) { this->width = screen_width = width; this->height = screen_height = height; } + void PresentFrame(vk::Image image, vk::ImageView imageView, const vk::Extent2D& extent); + + vk::PhysicalDevice GetPhysicalDevice() const { return physicalDevice; } + vk::Device GetDevice() const { return device; } + vk::PipelineCache GetPipelineCache() const { return *pipelineCache; } + vk::DescriptorPool GetDescriptorPool() const { return *descriptorPool; } + vk::Extent2D GetViewPort() const { return { width, height }; } + int GetSwapChainSize() const { u32 m = retro_render_if->get_sync_index_mask(retro_render_if->handle); u32 n = 1; while (m >>= 1) n++; return n; } + int GetCurrentImageIndex() const { return retro_render_if->get_sync_index(retro_render_if->handle); } + // FIXME that's not quite correct + void WaitIdle() const { retro_render_if->wait_sync_index(retro_render_if->handle); } + void SubmitCommandBuffers(u32 bufferCount, vk::CommandBuffer *buffers, vk::Fence fence) { + retro_render_if->lock_queue(retro_render_if->handle); + queue.submit(vk::SubmitInfo(0, nullptr, nullptr, bufferCount, buffers, 0, nullptr), fence); + retro_render_if->unlock_queue(retro_render_if->handle); + } + vk::DeviceSize GetUniformBufferAlignment() const { return uniformBufferAlignment; } + vk::DeviceSize GetStorageBufferAlignment() const { return storageBufferAlignment; } + bool IsFormatSupported(TextureType textureType) + { + switch (textureType) + { + case TextureType::_4444: + return optimalTilingSupported4444; + case TextureType::_565: + return optimalTilingSupported565; + case TextureType::_5551: + return optimalTilingSupported1555; + default: + return true; + } + } + std::string GetDriverName() const { vk::PhysicalDeviceProperties props; physicalDevice.getProperties(&props); return props.deviceName; } + std::string GetDriverVersion() const { + vk::PhysicalDeviceProperties props; + physicalDevice.getProperties(&props); + + return std::to_string(VK_VERSION_MAJOR(props.driverVersion)) + + "." + std::to_string(VK_VERSION_MINOR(props.driverVersion)) + + "." + std::to_string(VK_VERSION_PATCH(props.driverVersion)); + } + vk::Format GetColorFormat() const { return colorFormat; } + vk::Format GetDepthFormat() const { return depthFormat; } + static VulkanContext *Instance() { return contextInstance; } + bool SupportsSamplerAnisotropy() const { return samplerAnisotropy; } + bool SupportsDedicatedAllocation() const { return dedicatedAllocationSupported; } + const VMAllocator& GetAllocator() const { return allocator; } + vk::DeviceSize GetMaxMemoryAllocationSize() const { return maxMemoryAllocationSize; } + f32 GetMaxSamplerAnisotropy() const { return samplerAnisotropy ? maxSamplerAnisotropy : 1.f; } + u32 GetVendorID() const { return vendorID; } + +private: + VMAllocator allocator; + u32 width = 0; + u32 height = 0; + + vk::DeviceSize uniformBufferAlignment = 0; + vk::DeviceSize storageBufferAlignment = 0; + u32 maxStorageBufferRange = 0; + vk::DeviceSize maxMemoryAllocationSize = 0; + bool optimalTilingSupported565 = false; + bool optimalTilingSupported1555 = false; + bool optimalTilingSupported4444 = false; +public: + bool samplerAnisotropy = false; + f32 maxSamplerAnisotropy = 0.f; + bool dedicatedAllocationSupported = false; +private: + u32 vendorID = 0; + vk::Format colorFormat = vk::Format::eR8G8B8A8Unorm; + + vk::UniqueDescriptorPool descriptorPool; + + vk::Format depthFormat = vk::Format::eUndefined; + + vk::UniquePipelineCache pipelineCache; + + retro_hw_render_interface_vulkan *retro_render_if = nullptr; + vk::Instance instance; + vk::PhysicalDevice physicalDevice; + vk::Device device; + vk::Queue queue; + + retro_vulkan_image retro_image; + + static VulkanContext *contextInstance; +}; + +const VkApplicationInfo* VkGetApplicationInfo(); +bool VkCreateDevice(retro_vulkan_context* context, VkInstance instance, VkPhysicalDevice gpu, + VkSurfaceKHR surface, PFN_vkGetInstanceProcAddr get_instance_proc_addr, + const char** required_device_extensions, + unsigned num_required_device_extensions, + const char** required_device_layers, unsigned num_required_device_layers, + const VkPhysicalDeviceFeatures* required_features); diff --git a/core/rend/vulkan/vulkan.h b/core/rend/vulkan/vulkan.h index 87c2c6c39..c04c5bd15 100644 --- a/core/rend/vulkan/vulkan.h +++ b/core/rend/vulkan/vulkan.h @@ -21,7 +21,17 @@ #pragma once #include "types.h" +#ifdef LIBRETRO +#include + +static inline PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *name) { + return (*vulkan_symbol_wrapper_instance_proc_addr())(instance, name); +} + +#else #include "volk/volk.h" +#endif + #undef VK_NO_PROTOTYPES #include "vulkan/vulkan.hpp" diff --git a/core/rend/vulkan/vulkan_context.cpp b/core/rend/vulkan/vulkan_context.cpp index 46648714a..6ce4591fd 100644 --- a/core/rend/vulkan/vulkan_context.cpp +++ b/core/rend/vulkan/vulkan_context.cpp @@ -268,44 +268,6 @@ bool VulkanContext::InitInstance(const char** extensions, uint32_t extensions_co return false; } -vk::Format VulkanContext::FindDepthFormat() -{ - const vk::Format depthFormats[] = { vk::Format::eD32SfloatS8Uint, vk::Format::eD24UnormS8Uint, vk::Format::eD16UnormS8Uint }; - vk::ImageTiling tiling; - depthFormat = vk::Format::eUndefined; - for (size_t i = 0; i < ARRAY_SIZE(depthFormats); i++) - { - vk::FormatProperties formatProperties = physicalDevice.getFormatProperties(depthFormats[i]); - - if (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) - { - tiling = vk::ImageTiling::eOptimal; - depthFormat = depthFormats[i]; - break; - } - } - if (depthFormat == vk::Format::eUndefined) - { - // Try to find a linear format - for (size_t i = 0; i < ARRAY_SIZE(depthFormats); i++) - { - vk::FormatProperties formatProperties = physicalDevice.getFormatProperties(depthFormats[i]); - - if (formatProperties.linearTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) - { - tiling = vk::ImageTiling::eLinear; - depthFormat = depthFormats[i]; - break; - } - } - if (depthFormat == vk::Format::eUndefined) - die("No supported depth/stencil format found"); - } - NOTICE_LOG(RENDERER, "Using depth format %s tiling %s", vk::to_string(depthFormat).c_str(), vk::to_string(tiling).c_str()); - - return depthFormat; -} - void VulkanContext::InitImgui() { gui_init(); @@ -644,7 +606,7 @@ void VulkanContext::CreateSwapChain() commandBuffers.push_back(std::move(device->allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo(*commandPools.back(), vk::CommandBufferLevel::ePrimary, 1)).front())); } - FindDepthFormat(); + depthFormat = findDepthFormat(physicalDevice); // Render pass vk::AttachmentDescription attachmentDescription = vk::AttachmentDescription(vk::AttachmentDescriptionFlags(), colorFormat, vk::SampleCountFlagBits::e1, @@ -893,12 +855,12 @@ vk::CommandBuffer VulkanContext::PrepareOverlay(bool vmu, bool crosshair) void VulkanContext::DrawOverlay(float scaling, bool vmu, bool crosshair) { if (IsValid()) - overlay->Draw(vk::Extent2D(width, height), scaling, vmu, crosshair); + overlay->Draw(GetCurrentCommandBuffer(), vk::Extent2D(width, height), scaling, vmu, crosshair); } extern Renderer *renderer; -void VulkanContext::PresentFrame(vk::ImageView imageView, const vk::Extent2D& extent) noexcept +void VulkanContext::PresentFrame(vk::Image image, vk::ImageView imageView, const vk::Extent2D& extent) noexcept { lastFrameView = imageView; lastFrameExtent = extent; diff --git a/core/rend/vulkan/vulkan_context.h b/core/rend/vulkan/vulkan_context.h index d473ab864..7b3abc8dc 100644 --- a/core/rend/vulkan/vulkan_context.h +++ b/core/rend/vulkan/vulkan_context.h @@ -22,6 +22,25 @@ #ifdef USE_VULKAN #include + +class InvalidVulkanContext : public std::runtime_error { +public: + InvalidVulkanContext() : std::runtime_error("Invalid Vulkan context") {} +}; + +#define VENDOR_AMD 0x1022 +// AMD GPU products use the ATI vendor Id +#define VENDOR_ATI 0x1002 +#define VENDOR_ARM 0x13B5 +#define VENDOR_INTEL 0x8086 +#define VENDOR_NVIDIA 0x10DE +#define VENDOR_QUALCOMM 0x5143 +#define VENDOR_MESA 0x10005 + +#ifdef LIBRETRO +#include "vk_context_lr.h" +#else + #include "vulkan.h" #include "vmallocator.h" #include "quad.h" @@ -32,15 +51,7 @@ extern int screen_width, screen_height; struct ImDrawData; void ImGui_ImplVulkan_RenderDrawData(ImDrawData *draw_data); - -#define VENDOR_AMD 0x1022 -// AMD GPU products use the ATI vendor Id -#define VENDOR_ATI 0x1002 -#define VENDOR_ARM 0x13B5 -#define VENDOR_INTEL 0x8086 -#define VENDOR_NVIDIA 0x10DE -#define VENDOR_QUALCOMM 0x5143 -#define VENDOR_MESA 0x10005 +static vk::Format findDepthFormat(vk::PhysicalDevice physicalDevice); class VulkanContext { @@ -60,7 +71,7 @@ public: void BeginRenderPass(); void EndFrame(vk::CommandBuffer cmdBuffer = vk::CommandBuffer()); void Present() noexcept; - void PresentFrame(vk::ImageView imageView, const vk::Extent2D& extent) noexcept; + void PresentFrame(vk::Image image, vk::ImageView imageView, const vk::Extent2D& extent) noexcept; void PresentLastFrame(); vk::PhysicalDevice GetPhysicalDevice() const { return physicalDevice; } @@ -74,7 +85,6 @@ public: int GetCurrentImageIndex() const { return currentImage; } void WaitIdle() const; bool IsRendering() const { return rendering; } - vk::Queue GetGraphicsQueue() const { return graphicsQueue; } vk::DeviceSize GetUniformBufferAlignment() const { return uniformBufferAlignment; } vk::DeviceSize GetStorageBufferAlignment() const { return storageBufferAlignment; } bool IsFormatSupported(TextureType textureType) @@ -107,6 +117,10 @@ public: u32 GetVendorID() const { return vendorID; } vk::CommandBuffer PrepareOverlay(bool vmu, bool crosshair); void DrawOverlay(float scaling, bool vmu, bool crosshair); + void SubmitCommandBuffers(u32 bufferCount, vk::CommandBuffer *buffers, vk::Fence fence) { + graphicsQueue.submit( + vk::SubmitInfo(0, nullptr, nullptr, bufferCount, buffers), fence); + } #ifdef VK_DEBUG void setObjectName(u64 object, VkDebugReportObjectTypeEXT objectType, const std::string& name) @@ -124,7 +138,6 @@ private: void CreateSwapChain(); bool InitDevice(); bool InitInstance(const char** extensions, uint32_t extensions_count); - vk::Format FindDepthFormat(); void InitImgui(); void DoSwapAutomation(); void DrawFrame(vk::ImageView imageView, const vk::Extent2D& extent); @@ -213,10 +226,44 @@ private: #endif static VulkanContext *contextInstance; }; +#endif // !LIBRETRO -class InvalidVulkanContext : public std::runtime_error { -public: - InvalidVulkanContext() : std::runtime_error("Invalid Vulkan context") {} -}; +static inline vk::Format findDepthFormat(vk::PhysicalDevice physicalDevice) +{ + const vk::Format depthFormats[] = { vk::Format::eD32SfloatS8Uint, vk::Format::eD24UnormS8Uint, vk::Format::eD16UnormS8Uint }; + vk::ImageTiling tiling; + vk::Format depthFormat = vk::Format::eUndefined; + for (size_t i = 0; i < ARRAY_SIZE(depthFormats); i++) + { + vk::FormatProperties formatProperties = physicalDevice.getFormatProperties(depthFormats[i]); + + if (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) + { + tiling = vk::ImageTiling::eOptimal; + depthFormat = depthFormats[i]; + break; + } + } + if (depthFormat == vk::Format::eUndefined) + { + // Try to find a linear format + for (size_t i = 0; i < ARRAY_SIZE(depthFormats); i++) + { + vk::FormatProperties formatProperties = physicalDevice.getFormatProperties(depthFormats[i]); + + if (formatProperties.linearTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) + { + tiling = vk::ImageTiling::eLinear; + depthFormat = depthFormats[i]; + break; + } + } + if (depthFormat == vk::Format::eUndefined) + die("No supported depth/stencil format found"); + } + NOTICE_LOG(RENDERER, "Using depth format %s tiling %s", vk::to_string(depthFormat).c_str(), vk::to_string(tiling).c_str()); + + return depthFormat; +} #endif // USE_VULKAN diff --git a/core/rend/vulkan/vulkan_renderer.cpp b/core/rend/vulkan/vulkan_renderer.cpp index 977b3d635..21de9c172 100644 --- a/core/rend/vulkan/vulkan_renderer.cpp +++ b/core/rend/vulkan/vulkan_renderer.cpp @@ -28,14 +28,14 @@ class VulkanRenderer final : public BaseVulkanRenderer public: bool Init() override { - DEBUG_LOG(RENDERER, "VulkanRenderer::Init"); - BaseVulkanRenderer::Init(); + NOTICE_LOG(RENDERER, "VulkanRenderer::Init"); textureDrawer.Init(&samplerManager, &shaderManager, &textureCache); textureDrawer.SetCommandPool(&texCommandPool); screenDrawer.Init(&samplerManager, &shaderManager, viewport); screenDrawer.SetCommandPool(&texCommandPool); + BaseInit(screenDrawer.GetRenderPass()); return true; } @@ -66,6 +66,11 @@ public: drawer->Draw(fogTexture.get(), paletteTexture.get()); +#ifdef LIBRETRO + if (!pvrrc.isRTT) + overlay->Draw(screenDrawer.GetCurrentCommandBuffer(), viewport, (int)config::RenderResolution / 480.f, true, true); +#endif + drawer->EndRenderPass(); return !pvrrc.isRTT; diff --git a/core/rend/vulkan/vulkan_renderer.h b/core/rend/vulkan/vulkan_renderer.h index 684a0e542..d22554dfd 100644 --- a/core/rend/vulkan/vulkan_renderer.h +++ b/core/rend/vulkan/vulkan_renderer.h @@ -21,16 +21,19 @@ #include "hw/pvr/ta.h" #include "commandpool.h" #include "pipeline.h" -#include "rend/gui.h" #include "rend/osd.h" +#include "overlay.h" +#ifndef LIBRETRO +#include "rend/gui.h" +#endif #include #include class BaseVulkanRenderer : public Renderer { -public: - bool Init() override +protected: + bool BaseInit(vk::RenderPass renderPass, int subpass = 0) { texCommandPool.Init(); @@ -62,13 +65,24 @@ public: vk::BufferUsageFlagBits::eVertexBuffer)); } #endif - +#ifdef LIBRETRO + quadPipeline = std::unique_ptr(new QuadPipeline()); + quadPipeline->Init(&shaderManager, renderPass); + overlay = std::unique_ptr(new VulkanOverlay()); + overlay->Init(quadPipeline.get()); +#endif return true; } +public: void Term() override { - GetContext()->PresentFrame(nullptr, vk::Extent2D()); + GetContext()->PresentFrame(nullptr, nullptr, vk::Extent2D()); +#ifdef LIBRETRO + overlay->Term(); + overlay.reset(); + quadPipeline.reset(); +#endif osdBuffer.reset(); vjoyTexture.reset(); textureCache.Clear(); @@ -130,6 +144,10 @@ public: if (result) { +#ifdef LIBRETRO + if (!ctx->rend.isRTT) + overlay->Prepare(texCommandBuffer, true, true); +#endif CheckFogTexture(); CheckPaletteTexture(); texCommandBuffer.end(); @@ -161,6 +179,7 @@ public: void DrawOSD(bool clear_screen) override { +#ifndef LIBRETRO gui_display_osd(); if (!vjoyTexture) return; @@ -202,6 +221,7 @@ public: GetContext()->EndFrame(); } catch (const InvalidVulkanContext&) { } +#endif } protected: @@ -352,4 +372,8 @@ protected: TextureCache textureCache; vk::Extent2D viewport; vk::CommandBuffer texCommandBuffer; +#ifdef LIBRETRO + std::unique_ptr overlay; + std::unique_ptr quadPipeline; +#endif }; diff --git a/shell/libretro/libretro.cpp b/shell/libretro/libretro.cpp index 643e4d01d..37580e261 100644 --- a/shell/libretro/libretro.cpp +++ b/shell/libretro/libretro.cpp @@ -481,7 +481,7 @@ static void update_variables(bool first_startup) { if (config::RendererType == RenderType::Vulkan_OIT) config::RendererType = RenderType::Vulkan; - else + else if (config::RendererType != RenderType::Vulkan) config::RendererType = RenderType::OpenGL; config::PerStripSorting = true; } @@ -489,7 +489,7 @@ static void update_variables(bool first_startup) { if (config::RendererType == RenderType::Vulkan_OIT) config::RendererType = RenderType::Vulkan; - else + else if (config::RendererType != RenderType::Vulkan) config::RendererType = RenderType::OpenGL; config::PerStripSorting = false; } @@ -497,7 +497,7 @@ static void update_variables(bool first_startup) { if (config::RendererType == RenderType::Vulkan) config::RendererType = RenderType::Vulkan_OIT; - else + else if (config::RendererType != RenderType::Vulkan_OIT) config::RendererType = RenderType::OpenGL_OIT; config::PerStripSorting = false; // Not used } @@ -506,7 +506,7 @@ static void update_variables(bool first_startup) { if (config::RendererType == RenderType::Vulkan_OIT) config::RendererType = RenderType::Vulkan; - else + else if (config::RendererType != RenderType::Vulkan) config::RendererType = RenderType::OpenGL; config::PerStripSorting = false; } @@ -1260,6 +1260,8 @@ static void retro_vk_context_reset() width = width * 4 / 3; theVulkanContext.SetWindowSize(width, config::RenderResolution); theVulkanContext.Init((retro_hw_render_interface_vulkan *)vulkan); + rend_term_renderer(); + rend_init_renderer(); } static void retro_vk_context_destroy() @@ -1295,8 +1297,6 @@ static bool set_vulkan_hw_render() else if (config::RendererType == RenderType::OpenGL_OIT) config::RendererType = RenderType::Vulkan_OIT; config::RendererType.commit(); - rend_term_renderer(); - rend_init_renderer(); return true; } #else diff --git a/shell/libretro/vmu_xhair.cpp b/shell/libretro/vmu_xhair.cpp index 519a5ed1c..a35f636a1 100644 --- a/shell/libretro/vmu_xhair.cpp +++ b/shell/libretro/vmu_xhair.cpp @@ -79,7 +79,7 @@ const rgb_t VMU_SCREEN_COLOR_MAP[VMU_NUM_COLORS] = { { 0xFF, 0xFF, 0xFF } }; -vmu_screen_params_t vmu_screen_params[4] ; +vmu_screen_params_t vmu_screen_params[4]; u8 lightgun_img_crosshair[LIGHTGUN_CROSSHAIR_SIZE*LIGHTGUN_CROSSHAIR_SIZE] = { @@ -110,5 +110,9 @@ u8 lightgun_palette[LIGHTGUN_COLORS_COUNT*3] = 0x10,0x10,0xff, // LIGHTGUN_COLOR_BLUE }; -lightgun_params_t lightgun_params[4] ; +lightgun_params_t lightgun_params[4]; +std::pair getCrosshairPosition(int playerNum) +{ + return std::make_pair(lightgun_params[playerNum].x, lightgun_params[playerNum].y); +}