ShuriZma
/
flycast
mirror of https://github.com/flyinghead/flycast.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

libretro: vulkan support

This commit is contained in:
Flyinghead 2021-07-08 12:47:00 +02:00
parent 673c2988d6
commit b66e6560ca
21 changed files with 1479 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
CMakeLists.txt
View File

@ -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()

811
core/deps/libretro-common/vulkan/vulkan_symbol_wrapper.c Normal file
View File

@ -0,0 +1,811 @@
/* This header is autogenerated by vulkan_loader_generator.py */
#include <vulkan/vulkan_symbol_wrapper.h>
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;
}

2
core/rend/dx9/d3d_overlay.cpp
View File

@ -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)

6
core/rend/gui.cpp
View File

@ -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]);
}

17
core/rend/gui.h
View File

@ -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<float, float> getCrosshairPosition(int playerNum);

19
core/rend/osd.h
View File

@ -17,6 +17,7 @@
#pragma once
#include "types.h"
#include "cfg/option.h"
#include <vector>
#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<float, float> 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;
}

3
core/rend/vulkan/commandpool.h
View File

@ -59,8 +59,7 @@ public:
void EndFrame()
{
std::vector<vk::CommandBuffer> 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()

5
core/rend/vulkan/drawer.h
View File

@ -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;

7
core/rend/vulkan/oit/oit_drawer.h
View File

@ -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()]; }

10
core/rend/vulkan/oit/oit_renderer.cpp
View File

@ -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();

36
core/rend/vulkan/overlay.cpp
View File

@ -19,7 +19,6 @@
along with Flycast. If not, see <https://www.gnu.org/licenses/>.
*/
#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<Texture> 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,

3
core/rend/vulkan/overlay.h
View File

@ -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<Texture> createTexture(vk::CommandBuffer commandBuffer, int width, int height, u8 *data);

324
core/rend/vulkan/vk_context_lr.cpp Normal file
View File

@ -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 <https://www.gnu.org/licenses/>.
*/
#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<vk::QueueFamilyProperties> 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<const char *> 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<u8> 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();
}

136
core/rend/vulkan/vk_context_lr.h Normal file
View File

@ -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 <https://www.gnu.org/licenses/>.
*/
#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);

10
core/rend/vulkan/vulkan.h
View File

@ -21,7 +21,17 @@
#pragma once
#include "types.h"
#ifdef LIBRETRO
#include <vulkan/vulkan_symbol_wrapper.h>
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"

44
core/rend/vulkan/vulkan_context.cpp
View File

@ -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;

79
core/rend/vulkan/vulkan_context.h
View File

@ -22,6 +22,25 @@
#ifdef USE_VULKAN
#include <stdexcept>
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

9
core/rend/vulkan/vulkan_renderer.cpp
View File

@ -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;

34
core/rend/vulkan/vulkan_renderer.h
View File

@ -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 <memory>
#include <vector>
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<QuadPipeline>(new QuadPipeline());
quadPipeline->Init(&shaderManager, renderPass);
overlay = std::unique_ptr<VulkanOverlay>(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<VulkanOverlay> overlay;
std::unique_ptr<QuadPipeline> quadPipeline;
#endif
};

12
shell/libretro/libretro.cpp
View File

@ -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

8
shell/libretro/vmu_xhair.cpp
View File

@ -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<float, float> getCrosshairPosition(int playerNum)
{
return std::make_pair(lightgun_params[playerNum].x, lightgun_params[playerNum].y);
}