kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-01-11 14:43:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixing vulkan loader, moving vulkan pfns to RenderCore

Browse Source
This commit is contained in:
kbz_8
2024-09-20 16:14:14 +02:00
parent f4e4672cc6
commit 092e5acd9b
22 changed files with 821 additions and 684 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/Includes/Core/Application.h
View File

@@ -47,6 +47,7 @@ namespace mlx
~Application(); ~Application();
private: private:
RenderCore m_render_core;
FpsManager m_fps; FpsManager m_fps;
Inputs m_in; Inputs m_in;
ImageRegistry m_image_registry; ImageRegistry m_image_registry;

3
runtime/Includes/PreCompiled.h
View File

@@ -9,6 +9,8 @@
#include <cstdarg> #include <cstdarg>
#include <iostream> #include <iostream>
#include <vulkan/vulkan_core.h>
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <SDL2/SDL_vulkan.h> #include <SDL2/SDL_vulkan.h>
@@ -81,6 +83,7 @@
#include <Utils/AntiX11.h> #include <Utils/AntiX11.h>
#include <Utils/AntiWindows.h> #include <Utils/AntiWindows.h>
#define KVF_IMPL_VK_NO_PROTOTYPES
#ifdef DEBUG #ifdef DEBUG
#define KVF_ENABLE_VALIDATION_LAYERS #define KVF_ENABLE_VALIDATION_LAYERS
#endif #endif

4
runtime/Includes/Renderer/Buffer.h
View File

@@ -51,7 +51,7 @@ namespace mlx
public: public:
inline void Init(std::uint32_t size, VkBufferUsageFlags additional_flags = 0) { GPUBuffer::Init(BufferType::LowDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | additional_flags, {}); } inline void Init(std::uint32_t size, VkBufferUsageFlags additional_flags = 0) { GPUBuffer::Init(BufferType::LowDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | additional_flags, {}); }
void SetData(CPUBuffer data); void SetData(CPUBuffer data);
inline void Bind(VkCommandBuffer cmd) const noexcept { VkDeviceSize offset = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &m_buffer, &offset); } inline void Bind(VkCommandBuffer cmd) const noexcept { VkDeviceSize offset = 0; RenderCore::Get().vkCmdBindVertexBuffers(cmd, 0, 1, &m_buffer, &offset); }
}; };
class IndexBuffer : public GPUBuffer class IndexBuffer : public GPUBuffer
@@ -59,7 +59,7 @@ namespace mlx
public: public:
inline void Init(std::uint32_t size, VkBufferUsageFlags additional_flags = 0) { GPUBuffer::Init(BufferType::LowDynamic, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT | additional_flags, {}); } inline void Init(std::uint32_t size, VkBufferUsageFlags additional_flags = 0) { GPUBuffer::Init(BufferType::LowDynamic, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT | additional_flags, {}); }
void SetData(CPUBuffer data); void SetData(CPUBuffer data);
inline void Bind(VkCommandBuffer cmd) const noexcept { vkCmdBindIndexBuffer(cmd, m_buffer, 0, VK_INDEX_TYPE_UINT32); } inline void Bind(VkCommandBuffer cmd) const noexcept { RenderCore::Get().vkCmdBindIndexBuffer(cmd, m_buffer, 0, VK_INDEX_TYPE_UINT32); }
}; };
class UniformBuffer class UniformBuffer

1
runtime/Includes/Renderer/Descriptor.h
View File

@@ -4,7 +4,6 @@
#include <Renderer/Enums.h> #include <Renderer/Enums.h>
#include <Renderer/RenderCore.h> #include <Renderer/RenderCore.h>
#include <Renderer/Pipelines/Shader.h> #include <Renderer/Pipelines/Shader.h>
#include <Renderer/Vulkan/VulkanPrototypes.h>
namespace mlx namespace mlx
{ {

2
runtime/Includes/Renderer/Image.h
View File

@@ -99,7 +99,7 @@ namespace mlx
kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT); kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd); TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
kvfCopyBufferToImage(cmd, Image::Get(), staging_buffer.Get(), staging_buffer.GetOffset(), VK_IMAGE_ASPECT_COLOR_BIT, { width, height, 1 }); kvfCopyBufferToImage(cmd, Image::Get(), staging_buffer.Get(), staging_buffer.GetOffset(), VK_IMAGE_ASPECT_COLOR_BIT, { width, height, 1 });
vkEndCommandBuffer(cmd); RenderCore::Get().vkEndCommandBuffer(cmd);
VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice()); VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence); kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);
kvfDestroyFence(RenderCore::Get().GetDevice(), fence); kvfDestroyFence(RenderCore::Get().GetDevice(), fence);

4
runtime/Includes/Renderer/Pipelines/Pipeline.h
View File

@@ -1,8 +1,6 @@
#ifndef __MLX_PIPELINE__ #ifndef __MLX_PIPELINE__
#define __MLX_PIPELINE__ #define __MLX_PIPELINE__
#include <Renderer/Vulkan/VulkanPrototypes.h>
namespace mlx namespace mlx
{ {
class Pipeline class Pipeline
@@ -10,7 +8,7 @@ namespace mlx
public: public:
Pipeline() = default; Pipeline() = default;
inline virtual bool BindPipeline(VkCommandBuffer command_buffer) noexcept { vkCmdBindPipeline(command_buffer, GetPipelineBindPoint(), GetPipeline()); return true; } inline virtual bool BindPipeline(VkCommandBuffer command_buffer) noexcept { RenderCore::Get().vkCmdBindPipeline(command_buffer, GetPipelineBindPoint(), GetPipeline()); return true; }
inline virtual void EndPipeline([[maybe_unused]] VkCommandBuffer command_buffer) noexcept {} inline virtual void EndPipeline([[maybe_unused]] VkCommandBuffer command_buffer) noexcept {}
virtual VkPipeline GetPipeline() const = 0; virtual VkPipeline GetPipeline() const = 0;

30
runtime/Includes/Renderer/RenderCore.h
View File

@@ -1,21 +1,17 @@
#ifndef __MLX_RENDER_CORE__ #ifndef __MLX_RENDER_CORE__
#define __MLX_RENDER_CORE__ #define __MLX_RENDER_CORE__
#include <Renderer/Vulkan/VulkanPrototypes.h>
#include <Renderer/Memory.h> #include <Renderer/Memory.h>
namespace mlx namespace mlx
{ {
constexpr const int MAX_FRAMES_IN_FLIGHT = 3; constexpr const int MAX_FRAMES_IN_FLIGHT = 3;
class RenderCore : public Singleton<RenderCore> class RenderCore
{ {
friend class Singleton<RenderCore>; friend class Application;
public: public:
void Init() noexcept;
void Destroy() noexcept;
[[nodiscard]] MLX_FORCEINLINE VkInstance GetInstance() const noexcept { return m_instance; } [[nodiscard]] MLX_FORCEINLINE VkInstance GetInstance() const noexcept { return m_instance; }
[[nodiscard]] MLX_FORCEINLINE VkInstance& GetInstanceRef() noexcept { return m_instance; } [[nodiscard]] MLX_FORCEINLINE VkInstance& GetInstanceRef() noexcept { return m_instance; }
[[nodiscard]] MLX_FORCEINLINE VkDevice GetDevice() const noexcept { return m_device; } [[nodiscard]] MLX_FORCEINLINE VkDevice GetDevice() const noexcept { return m_device; }
@@ -24,11 +20,27 @@ namespace mlx
inline void WaitDeviceIdle() const noexcept { vkDeviceWaitIdle(m_device); } inline void WaitDeviceIdle() const noexcept { vkDeviceWaitIdle(m_device); }
private: inline static bool IsInit() noexcept { return s_instance != nullptr; }
RenderCore() = default; inline static RenderCore& Get() noexcept { return *s_instance; }
~RenderCore() = default;
#define MLX_VULKAN_GLOBAL_FUNCTION(fn) PFN_##fn fn = nullptr;
#define MLX_VULKAN_INSTANCE_FUNCTION(fn) PFN_##fn fn = nullptr;
#define MLX_VULKAN_DEVICE_FUNCTION(fn) PFN_##fn fn = nullptr;
#include <Renderer/Vulkan/VulkanDefs.h>
#undef MLX_VULKAN_GLOBAL_FUNCTION
#undef MLX_VULKAN_INSTANCE_FUNCTION
#undef MLX_VULKAN_DEVICE_FUNCTION
private: private:
RenderCore();
void LoadKVFGlobalVulkanFunctionPointers() const noexcept;
void LoadKVFInstanceVulkanFunctionPointers() const noexcept;
void LoadKVFDeviceVulkanFunctionPointers() const noexcept;
~RenderCore();
private:
static RenderCore* s_instance;
GPUAllocator m_allocator; GPUAllocator m_allocator;
VkInstance m_instance = VK_NULL_HANDLE; VkInstance m_instance = VK_NULL_HANDLE;
VkDevice m_device = VK_NULL_HANDLE; VkDevice m_device = VK_NULL_HANDLE;

121
runtime/Includes/Renderer/Vulkan/VulkanDefs.h git.filemode.normal_file
View File

@@ -0,0 +1,121 @@
// No header guard
#ifdef VK_VERSION_1_0
#ifdef MLX_VULKAN_GLOBAL_FUNCTION
MLX_VULKAN_GLOBAL_FUNCTION(vkCreateInstance)
MLX_VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties)
MLX_VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties)
MLX_VULKAN_GLOBAL_FUNCTION(vkGetInstanceProcAddr)
#endif
#ifdef MLX_VULKAN_INSTANCE_FUNCTION
MLX_VULKAN_INSTANCE_FUNCTION(vkCreateDevice)
MLX_VULKAN_INSTANCE_FUNCTION(vkDestroyInstance)
MLX_VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties)
MLX_VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFormatProperties)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceImageFormatProperties)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties)
#endif
#ifdef MLX_VULKAN_DEVICE_FUNCTION
MLX_VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers)
MLX_VULKAN_DEVICE_FUNCTION(vkAllocateDescriptorSets)
MLX_VULKAN_DEVICE_FUNCTION(vkAllocateMemory)
MLX_VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkBindBufferMemory)
MLX_VULKAN_DEVICE_FUNCTION(vkBindImageMemory)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdBeginRenderPass)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdBindDescriptorSets)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdBindIndexBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdBindPipeline)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdBindVertexBuffers)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdClearAttachments)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdClearColorImage)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdClearDepthStencilImage)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdCopyBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdCopyBufferToImage)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdCopyImage)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdCopyImageToBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdDraw)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdDrawIndexed)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdEndRenderPass)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdPushConstants)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdSetScissor)
MLX_VULKAN_DEVICE_FUNCTION(vkCmdSetViewport)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateCommandPool)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateDescriptorPool)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateDescriptorSetLayout)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateFence)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateFramebuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateGraphicsPipelines)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateImage)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateImageView)
MLX_VULKAN_DEVICE_FUNCTION(vkCreatePipelineLayout)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateRenderPass)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateSampler)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateSemaphore)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateShaderModule)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyDescriptorPool)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyDescriptorSetLayout)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyDevice)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyFence)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyFramebuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyImage)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyImageView)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyPipeline)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyPipelineLayout)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyRenderPass)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroySampler)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroySemaphore)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroyShaderModule)
MLX_VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle)
MLX_VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkFlushMappedMemoryRanges)
MLX_VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers)
MLX_VULKAN_DEVICE_FUNCTION(vkFreeMemory)
MLX_VULKAN_DEVICE_FUNCTION(vkGetBufferMemoryRequirements)
MLX_VULKAN_DEVICE_FUNCTION(vkGetDeviceMemoryCommitment)
MLX_VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue)
MLX_VULKAN_DEVICE_FUNCTION(vkGetFenceStatus)
MLX_VULKAN_DEVICE_FUNCTION(vkGetImageMemoryRequirements)
MLX_VULKAN_DEVICE_FUNCTION(vkGetImageSubresourceLayout)
MLX_VULKAN_DEVICE_FUNCTION(vkInvalidateMappedMemoryRanges)
MLX_VULKAN_DEVICE_FUNCTION(vkMapMemory)
MLX_VULKAN_DEVICE_FUNCTION(vkQueueSubmit)
MLX_VULKAN_DEVICE_FUNCTION(vkQueueWaitIdle)
MLX_VULKAN_DEVICE_FUNCTION(vkResetCommandBuffer)
MLX_VULKAN_DEVICE_FUNCTION(vkResetDescriptorPool)
MLX_VULKAN_DEVICE_FUNCTION(vkResetEvent)
MLX_VULKAN_DEVICE_FUNCTION(vkResetFences)
MLX_VULKAN_DEVICE_FUNCTION(vkUnmapMemory)
MLX_VULKAN_DEVICE_FUNCTION(vkUpdateDescriptorSets)
MLX_VULKAN_DEVICE_FUNCTION(vkWaitForFences)
#endif
#endif
#ifdef VK_KHR_swapchain
#ifdef MLX_VULKAN_DEVICE_FUNCTION
MLX_VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR)
MLX_VULKAN_DEVICE_FUNCTION(vkCreateSwapchainKHR)
MLX_VULKAN_DEVICE_FUNCTION(vkDestroySwapchainKHR)
MLX_VULKAN_DEVICE_FUNCTION(vkGetSwapchainImagesKHR)
MLX_VULKAN_DEVICE_FUNCTION(vkQueuePresentKHR)
#endif
#endif
#ifdef VK_KHR_surface
#ifdef MLX_VULKAN_INSTANCE_FUNCTION
MLX_VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR)
MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR)
#endif
#endif

170
runtime/Includes/Renderer/Vulkan/VulkanPrototypes.h
View File

@@ -1,170 +0,0 @@
#ifndef __MLX_VK_PROTOTYPES__
#define __MLX_VK_PROTOTYPES__
#if defined(VULKAN_H_) && !defined(VK_NO_PROTOTYPES)
#error "define VK_NO_PROTOTYPES needed"
#endif
#ifndef VK_NO_PROTOTYPES
#define VK_NO_PROTOTYPES
#endif
#ifndef VULKAN_H_
#include <vulkan/vulkan.h>
#endif
#ifdef VK_VERSION_1_0
extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
extern PFN_vkAllocateMemory vkAllocateMemory;
extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
extern PFN_vkBindBufferMemory vkBindBufferMemory;
extern PFN_vkBindImageMemory vkBindImageMemory;
extern PFN_vkCmdBeginQuery vkCmdBeginQuery;
extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
extern PFN_vkCmdBindPipeline vkCmdBindPipeline;
extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
extern PFN_vkCmdBlitImage vkCmdBlitImage;
extern PFN_vkCmdClearAttachments vkCmdClearAttachments;
extern PFN_vkCmdClearColorImage vkCmdClearColorImage;
extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
extern PFN_vkCmdCopyImage vkCmdCopyImage;
extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
extern PFN_vkCmdDispatch vkCmdDispatch;
extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
extern PFN_vkCmdDraw vkCmdDraw;
extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
extern PFN_vkCmdEndQuery vkCmdEndQuery;
extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
extern PFN_vkCmdFillBuffer vkCmdFillBuffer;
extern PFN_vkCmdNextSubpass vkCmdNextSubpass;
extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
extern PFN_vkCmdPushConstants vkCmdPushConstants;
extern PFN_vkCmdResetEvent vkCmdResetEvent;
extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
extern PFN_vkCmdResolveImage vkCmdResolveImage;
extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
extern PFN_vkCmdSetEvent vkCmdSetEvent;
extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
extern PFN_vkCmdSetScissor vkCmdSetScissor;
extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
extern PFN_vkCmdSetViewport vkCmdSetViewport;
extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
extern PFN_vkCmdWaitEvents vkCmdWaitEvents;
extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
extern PFN_vkCreateBuffer vkCreateBuffer;
extern PFN_vkCreateBufferView vkCreateBufferView;
extern PFN_vkCreateCommandPool vkCreateCommandPool;
extern PFN_vkCreateComputePipelines vkCreateComputePipelines;
extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
extern PFN_vkCreateDevice vkCreateDevice;
extern PFN_vkCreateEvent vkCreateEvent;
extern PFN_vkCreateFence vkCreateFence;
extern PFN_vkCreateFramebuffer vkCreateFramebuffer;
extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
extern PFN_vkCreateImage vkCreateImage;
extern PFN_vkCreateImageView vkCreateImageView;
extern PFN_vkCreateInstance vkCreateInstance;
extern PFN_vkCreatePipelineCache vkCreatePipelineCache;
extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
extern PFN_vkCreateQueryPool vkCreateQueryPool;
extern PFN_vkCreateRenderPass vkCreateRenderPass;
extern PFN_vkCreateSampler vkCreateSampler;
extern PFN_vkCreateSemaphore vkCreateSemaphore;
extern PFN_vkCreateShaderModule vkCreateShaderModule;
extern PFN_vkDestroyBuffer vkDestroyBuffer;
extern PFN_vkDestroyBufferView vkDestroyBufferView;
extern PFN_vkDestroyCommandPool vkDestroyCommandPool;
extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
extern PFN_vkDestroyDevice vkDestroyDevice;
extern PFN_vkDestroyEvent vkDestroyEvent;
extern PFN_vkDestroyFence vkDestroyFence;
extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
extern PFN_vkDestroyImage vkDestroyImage;
extern PFN_vkDestroyImageView vkDestroyImageView;
extern PFN_vkDestroyInstance vkDestroyInstance;
extern PFN_vkDestroyPipeline vkDestroyPipeline;
extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
extern PFN_vkDestroyQueryPool vkDestroyQueryPool;
extern PFN_vkDestroyRenderPass vkDestroyRenderPass;
extern PFN_vkDestroySampler vkDestroySampler;
extern PFN_vkDestroySemaphore vkDestroySemaphore;
extern PFN_vkDestroyShaderModule vkDestroyShaderModule;
extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
extern PFN_vkEndCommandBuffer vkEndCommandBuffer;
extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
extern PFN_vkFreeMemory vkFreeMemory;
extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
extern PFN_vkGetDeviceQueue vkGetDeviceQueue;
extern PFN_vkGetEventStatus vkGetEventStatus;
extern PFN_vkGetFenceStatus vkGetFenceStatus;
extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
extern PFN_vkMapMemory vkMapMemory;
extern PFN_vkMergePipelineCaches vkMergePipelineCaches;
extern PFN_vkQueueBindSparse vkQueueBindSparse;
extern PFN_vkQueueSubmit vkQueueSubmit;
extern PFN_vkQueueWaitIdle vkQueueWaitIdle;
extern PFN_vkResetCommandBuffer vkResetCommandBuffer;
extern PFN_vkResetCommandPool vkResetCommandPool;
extern PFN_vkResetDescriptorPool vkResetDescriptorPool;
extern PFN_vkResetEvent vkResetEvent;
extern PFN_vkResetFences vkResetFences;
extern PFN_vkSetEvent vkSetEvent;
extern PFN_vkUnmapMemory vkUnmapMemory;
extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
extern PFN_vkWaitForFences vkWaitForFences;
#endif
#ifdef VK_KHR_swapchain
extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
extern PFN_vkQueuePresentKHR vkQueuePresentKHR;
#endif
#ifdef VK_KHR_surface
extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
#endif
#endif

2
runtime/Sources/Core/Application.cpp
View File

@@ -8,7 +8,7 @@
namespace mlx namespace mlx
{ {
Application::Application() : m_fps(), m_in() Application::Application() : m_render_core(), m_fps(), m_in()
{ {
EventBus::RegisterListener({[](const EventBase& event) EventBus::RegisterListener({[](const EventBase& event)
{ {

2
runtime/Sources/Core/Bridge.cpp
View File

@@ -29,7 +29,6 @@ extern "C"
mlx::Application* app = new mlx::Application; mlx::Application* app = new mlx::Application;
if(app == nullptr) if(app == nullptr)
mlx::FatalError("Tout a pété"); mlx::FatalError("Tout a pété");
mlx::RenderCore::Get().Init();
__mlx_ptr = static_cast<void*>(app); __mlx_ptr = static_cast<void*>(app);
return __mlx_ptr; return __mlx_ptr;
} }
@@ -281,7 +280,6 @@ extern "C"
{ {
MLX_CHECK_APPLICATION_POINTER(mlx); MLX_CHECK_APPLICATION_POINTER(mlx);
delete static_cast<mlx::Application*>(mlx); delete static_cast<mlx::Application*>(mlx);
mlx::RenderCore::Get().Destroy();
__mlx_ptr = nullptr; __mlx_ptr = nullptr;
return 0; return 0;
} }

2
runtime/Sources/Graphics/Mesh.cpp
View File

@@ -15,7 +15,7 @@ namespace mlx
Verify(submesh_index < m_sub_meshes.size(), "invalid submesh index"); Verify(submesh_index < m_sub_meshes.size(), "invalid submesh index");
m_sub_meshes[submesh_index].vbo.Bind(cmd); m_sub_meshes[submesh_index].vbo.Bind(cmd);
m_sub_meshes[submesh_index].ibo.Bind(cmd); m_sub_meshes[submesh_index].ibo.Bind(cmd);
vkCmdDrawIndexed(cmd, static_cast<std::uint32_t>(m_sub_meshes[submesh_index].ibo.GetSize() / sizeof(std::uint32_t)), 1, 0, 0, 0); mlx::RenderCore::Get().vkCmdDrawIndexed(cmd, static_cast<std::uint32_t>(m_sub_meshes[submesh_index].ibo.GetSize() / sizeof(std::uint32_t)), 1, 0, 0, 0);
polygondrawn += m_sub_meshes[submesh_index].triangle_count; polygondrawn += m_sub_meshes[submesh_index].triangle_count;
drawcalls++; drawcalls++;
} }

2
runtime/Sources/Renderer/Descriptor.cpp
View File

@@ -136,7 +136,7 @@ namespace mlx
writes.push_back(kvfWriteStorageBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &buffer_infos.back(), descriptor.binding)); writes.push_back(kvfWriteStorageBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &buffer_infos.back(), descriptor.binding));
} }
} }
vkUpdateDescriptorSets(RenderCore::Get().GetDevice(), writes.size(), writes.data(), 0, nullptr); RenderCore::Get().vkUpdateDescriptorSets(RenderCore::Get().GetDevice(), writes.size(), writes.data(), 0, nullptr);
} }
void DescriptorSet::Reallocate() noexcept void DescriptorSet::Reallocate() noexcept

8
runtime/Sources/Renderer/Image.cpp
View File

@@ -76,7 +76,7 @@ namespace mlx
m_layout = new_layout; m_layout = new_layout;
if(is_single_time_cmd_buffer) if(is_single_time_cmd_buffer)
{ {
vkEndCommandBuffer(cmd); RenderCore::Get().vkEndCommandBuffer(cmd);
VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice()); VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence); kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);
kvfDestroyFence(RenderCore::Get().GetDevice(), fence); kvfDestroyFence(RenderCore::Get().GetDevice(), fence);
@@ -97,7 +97,7 @@ namespace mlx
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd); TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
VkClearColorValue clear_color = VkClearColorValue({ { color.x, color.y, color.z, color.w } }); VkClearColorValue clear_color = VkClearColorValue({ { color.x, color.y, color.z, color.w } });
vkCmdClearColorImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource_range); RenderCore::Get().vkCmdClearColorImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource_range);
TransitionLayout(old_layout, cmd); TransitionLayout(old_layout, cmd);
} }
else if(m_type == ImageType::Depth) else if(m_type == ImageType::Depth)
@@ -105,7 +105,7 @@ namespace mlx
VkClearDepthStencilValue clear_depth_stencil = { 1.0f, 1 }; VkClearDepthStencilValue clear_depth_stencil = { 1.0f, 1 };
subresource_range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; subresource_range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd); TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
vkCmdClearDepthStencilImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_depth_stencil, 1, &subresource_range); RenderCore::Get().vkCmdClearDepthStencilImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_depth_stencil, 1, &subresource_range);
} }
} }
@@ -189,7 +189,7 @@ namespace mlx
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, cmd); TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, cmd);
kvfCopyImageToBuffer(cmd, m_staging_buffer->Get(), m_image, m_staging_buffer->GetOffset(), VK_IMAGE_ASPECT_COLOR_BIT, { m_width, m_height, 1 }); kvfCopyImageToBuffer(cmd, m_staging_buffer->Get(), m_image, m_staging_buffer->GetOffset(), VK_IMAGE_ASPECT_COLOR_BIT, { m_width, m_height, 1 });
TransitionLayout(old_layout, cmd); TransitionLayout(old_layout, cmd);
vkEndCommandBuffer(cmd); RenderCore::Get().vkEndCommandBuffer(cmd);
VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice()); VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence); kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);
kvfDestroyFence(RenderCore::Get().GetDevice(), fence); kvfDestroyFence(RenderCore::Get().GetDevice(), fence);

34
runtime/Sources/Renderer/Memory.cpp
View File

@@ -27,23 +27,23 @@ namespace mlx
void GPUAllocator::Init() noexcept void GPUAllocator::Init() noexcept
{ {
VmaVulkanFunctions vma_vulkan_func{}; VmaVulkanFunctions vma_vulkan_func{};
vma_vulkan_func.vkAllocateMemory = vkAllocateMemory; vma_vulkan_func.vkAllocateMemory = RenderCore::Get().vkAllocateMemory;
vma_vulkan_func.vkBindBufferMemory = vkBindBufferMemory; vma_vulkan_func.vkBindBufferMemory = RenderCore::Get().vkBindBufferMemory;
vma_vulkan_func.vkBindImageMemory = vkBindImageMemory; vma_vulkan_func.vkBindImageMemory = RenderCore::Get().vkBindImageMemory;
vma_vulkan_func.vkCreateBuffer = vkCreateBuffer; vma_vulkan_func.vkCreateBuffer = RenderCore::Get().vkCreateBuffer;
vma_vulkan_func.vkCreateImage = vkCreateImage; vma_vulkan_func.vkCreateImage = RenderCore::Get().vkCreateImage;
vma_vulkan_func.vkDestroyBuffer = vkDestroyBuffer; vma_vulkan_func.vkDestroyBuffer = RenderCore::Get().vkDestroyBuffer;
vma_vulkan_func.vkDestroyImage = vkDestroyImage; vma_vulkan_func.vkDestroyImage = RenderCore::Get().vkDestroyImage;
vma_vulkan_func.vkFlushMappedMemoryRanges = vkFlushMappedMemoryRanges; vma_vulkan_func.vkFlushMappedMemoryRanges = RenderCore::Get().vkFlushMappedMemoryRanges;
vma_vulkan_func.vkFreeMemory = vkFreeMemory; vma_vulkan_func.vkFreeMemory = RenderCore::Get().vkFreeMemory;
vma_vulkan_func.vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirements; vma_vulkan_func.vkGetBufferMemoryRequirements = RenderCore::Get().vkGetBufferMemoryRequirements;
vma_vulkan_func.vkGetImageMemoryRequirements = vkGetImageMemoryRequirements; vma_vulkan_func.vkGetImageMemoryRequirements = RenderCore::Get().vkGetImageMemoryRequirements;
vma_vulkan_func.vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryProperties; vma_vulkan_func.vkGetPhysicalDeviceMemoryProperties = RenderCore::Get().vkGetPhysicalDeviceMemoryProperties;
vma_vulkan_func.vkGetPhysicalDeviceProperties = vkGetPhysicalDeviceProperties; vma_vulkan_func.vkGetPhysicalDeviceProperties = RenderCore::Get().vkGetPhysicalDeviceProperties;
vma_vulkan_func.vkInvalidateMappedMemoryRanges = vkInvalidateMappedMemoryRanges; vma_vulkan_func.vkInvalidateMappedMemoryRanges = RenderCore::Get().vkInvalidateMappedMemoryRanges;
vma_vulkan_func.vkMapMemory = vkMapMemory; vma_vulkan_func.vkMapMemory = RenderCore::Get().vkMapMemory;
vma_vulkan_func.vkUnmapMemory = vkUnmapMemory; vma_vulkan_func.vkUnmapMemory = RenderCore::Get().vkUnmapMemory;
vma_vulkan_func.vkCmdCopyBuffer = vkCmdCopyBuffer; vma_vulkan_func.vkCmdCopyBuffer = RenderCore::Get().vkCmdCopyBuffer;
VmaAllocatorCreateInfo allocator_create_info{}; VmaAllocatorCreateInfo allocator_create_info{};
allocator_create_info.vulkanApiVersion = VK_API_VERSION_1_0; allocator_create_info.vulkanApiVersion = VK_API_VERSION_1_0;

10
runtime/Sources/Renderer/Pipelines/Graphics.cpp
View File

@@ -30,7 +30,7 @@ namespace mlx
CreateFramebuffers(m_attachments, descriptor.clear_color_attachments); CreateFramebuffers(m_attachments, descriptor.clear_color_attachments);
VkPhysicalDeviceFeatures features{}; VkPhysicalDeviceFeatures features{};
vkGetPhysicalDeviceFeatures(RenderCore::Get().GetPhysicalDevice(), &features); mlx::RenderCore::Get().vkGetPhysicalDeviceFeatures(RenderCore::Get().GetPhysicalDevice(), &features);
KvfGraphicsPipelineBuilder* builder = kvfCreateGPipelineBuilder(); KvfGraphicsPipelineBuilder* builder = kvfCreateGPipelineBuilder();
kvfGPipelineBuilderAddShaderStage(builder, p_vertex_shader->GetShaderStage(), p_vertex_shader->GetShaderModule(), "main"); kvfGPipelineBuilderAddShaderStage(builder, p_vertex_shader->GetShaderStage(), p_vertex_shader->GetShaderModule(), "main");
@@ -73,12 +73,12 @@ namespace mlx
viewport.height = fb_extent.height; viewport.height = fb_extent.height;
viewport.minDepth = 0.0f; viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f; viewport.maxDepth = 1.0f;
vkCmdSetViewport(command_buffer, 0, 1, &viewport); RenderCore::Get().vkCmdSetViewport(command_buffer, 0, 1, &viewport);
VkRect2D scissor{}; VkRect2D scissor{};
scissor.offset = { 0, 0 }; scissor.offset = { 0, 0 };
scissor.extent = fb_extent; scissor.extent = fb_extent;
vkCmdSetScissor(command_buffer, 0, 1, &scissor); RenderCore::Get().vkCmdSetScissor(command_buffer, 0, 1, &scissor);
for(std::size_t i = 0; i < m_clears.size(); i++) for(std::size_t i = 0; i < m_clears.size(); i++)
{ {
@@ -92,13 +92,13 @@ namespace mlx
m_clears.back().depthStencil = VkClearDepthStencilValue{ 1.0f, 0 }; m_clears.back().depthStencil = VkClearDepthStencilValue{ 1.0f, 0 };
kvfBeginRenderPass(m_renderpass, command_buffer, fb, fb_extent, m_clears.data(), m_clears.size()); kvfBeginRenderPass(m_renderpass, command_buffer, fb, fb_extent, m_clears.data(), m_clears.size());
vkCmdBindPipeline(command_buffer, GetPipelineBindPoint(), GetPipeline()); RenderCore::Get().vkCmdBindPipeline(command_buffer, GetPipelineBindPoint(), GetPipeline());
return true; return true;
} }
void GraphicPipeline::EndPipeline(VkCommandBuffer command_buffer) noexcept void GraphicPipeline::EndPipeline(VkCommandBuffer command_buffer) noexcept
{ {
vkCmdEndRenderPass(command_buffer); RenderCore::Get().vkCmdEndRenderPass(command_buffer);
} }
void GraphicPipeline::Destroy() noexcept void GraphicPipeline::Destroy() noexcept

110
runtime/Sources/Renderer/RenderCore.cpp
View File

@@ -43,10 +43,16 @@ namespace mlx
std::cout << std::endl; std::cout << std::endl;
} }
void RenderCore::Init() noexcept RenderCore* RenderCore::s_instance = nullptr;
RenderCore::RenderCore()
{ {
s_instance = this;
loader = std::make_unique<VulkanLoader>(); loader = std::make_unique<VulkanLoader>();
LoadKVFGlobalVulkanFunctionPointers();
kvfSetErrorCallback(&ErrorCallback); kvfSetErrorCallback(&ErrorCallback);
kvfSetValidationErrorCallback(&ValidationErrorCallback); kvfSetValidationErrorCallback(&ValidationErrorCallback);
kvfSetValidationWarningCallback(&ValidationWarningCallback); kvfSetValidationWarningCallback(&ValidationWarningCallback);
@@ -63,6 +69,7 @@ namespace mlx
DebugLog("Vulkan : instance created"); DebugLog("Vulkan : instance created");
loader->LoadInstance(m_instance); loader->LoadInstance(m_instance);
LoadKVFInstanceVulkanFunctionPointers();
VkSurfaceKHR surface = window.CreateVulkanSurface(m_instance); VkSurfaceKHR surface = window.CreateVulkanSurface(m_instance);
@@ -80,12 +87,109 @@ namespace mlx
DebugLog("Vulkan : logical device created"); DebugLog("Vulkan : logical device created");
loader->LoadDevice(m_device); loader->LoadDevice(m_device);
LoadKVFDeviceVulkanFunctionPointers();
vkDestroySurfaceKHR(m_instance, surface, nullptr); vkDestroySurfaceKHR(m_instance, surface, nullptr);
FatalError("caca"); FatalError("caca");
} }
void RenderCore::Destroy() noexcept #undef MLX_LOAD_FUNCTION
#define MLX_LOAD_FUNCTION(fn) pfns.fn = this->fn
void RenderCore::LoadKVFGlobalVulkanFunctionPointers() const noexcept
{
KvfGlobalVulkanFunctions pfns;
MLX_LOAD_FUNCTION(vkCreateInstance);
MLX_LOAD_FUNCTION(vkEnumerateInstanceExtensionProperties);
MLX_LOAD_FUNCTION(vkEnumerateInstanceLayerProperties);
MLX_LOAD_FUNCTION(vkGetInstanceProcAddr);
kvfPassGlobalVulkanFunctionPointers(&pfns);
}
void RenderCore::LoadKVFInstanceVulkanFunctionPointers() const noexcept
{
KvfInstanceVulkanFunctions pfns;
MLX_LOAD_FUNCTION(vkCreateDevice);
MLX_LOAD_FUNCTION(vkDestroyInstance);
MLX_LOAD_FUNCTION(vkEnumerateDeviceExtensionProperties);
MLX_LOAD_FUNCTION(vkEnumeratePhysicalDevices);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceFeatures);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceFormatProperties);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceImageFormatProperties);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceMemoryProperties);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceProperties);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties);
MLX_LOAD_FUNCTION(vkDestroySurfaceKHR);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR);
MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR);
kvfPassInstanceVulkanFunctionPointers(&pfns);
}
void RenderCore::LoadKVFDeviceVulkanFunctionPointers() const noexcept
{
KvfDeviceVulkanFunctions pfns;
MLX_LOAD_FUNCTION(vkAllocateCommandBuffers);
MLX_LOAD_FUNCTION(vkAllocateDescriptorSets);
MLX_LOAD_FUNCTION(vkBeginCommandBuffer);
MLX_LOAD_FUNCTION(vkCmdBeginRenderPass);
MLX_LOAD_FUNCTION(vkCmdCopyBuffer);
MLX_LOAD_FUNCTION(vkCmdCopyBufferToImage);
MLX_LOAD_FUNCTION(vkCmdCopyImage);
MLX_LOAD_FUNCTION(vkCmdCopyImageToBuffer);
MLX_LOAD_FUNCTION(vkCmdEndRenderPass);
MLX_LOAD_FUNCTION(vkCmdPipelineBarrier);
MLX_LOAD_FUNCTION(vkCreateBuffer);
MLX_LOAD_FUNCTION(vkCreateCommandPool);
MLX_LOAD_FUNCTION(vkCreateDescriptorPool);
MLX_LOAD_FUNCTION(vkCreateDescriptorSetLayout);
MLX_LOAD_FUNCTION(vkCreateFence);
MLX_LOAD_FUNCTION(vkCreateFramebuffer);
MLX_LOAD_FUNCTION(vkCreateGraphicsPipelines);
MLX_LOAD_FUNCTION(vkCreateImage);
MLX_LOAD_FUNCTION(vkCreateImageView);
MLX_LOAD_FUNCTION(vkCreatePipelineLayout);
MLX_LOAD_FUNCTION(vkCreateRenderPass);
MLX_LOAD_FUNCTION(vkCreateSampler);
MLX_LOAD_FUNCTION(vkCreateSemaphore);
MLX_LOAD_FUNCTION(vkCreateShaderModule);
MLX_LOAD_FUNCTION(vkDestroyBuffer);
MLX_LOAD_FUNCTION(vkDestroyCommandPool);
MLX_LOAD_FUNCTION(vkDestroyDescriptorPool);
MLX_LOAD_FUNCTION(vkDestroyDescriptorSetLayout);
MLX_LOAD_FUNCTION(vkDestroyDevice);
MLX_LOAD_FUNCTION(vkDestroyFence);
MLX_LOAD_FUNCTION(vkDestroyFramebuffer);
MLX_LOAD_FUNCTION(vkDestroyImage);
MLX_LOAD_FUNCTION(vkDestroyImageView);
MLX_LOAD_FUNCTION(vkDestroyPipeline);
MLX_LOAD_FUNCTION(vkDestroyPipelineLayout);
MLX_LOAD_FUNCTION(vkDestroyRenderPass);
MLX_LOAD_FUNCTION(vkDestroySampler);
MLX_LOAD_FUNCTION(vkDestroySemaphore);
MLX_LOAD_FUNCTION(vkDestroyShaderModule);
MLX_LOAD_FUNCTION(vkDeviceWaitIdle);
MLX_LOAD_FUNCTION(vkEndCommandBuffer);
MLX_LOAD_FUNCTION(vkGetDeviceQueue);
MLX_LOAD_FUNCTION(vkGetImageSubresourceLayout);
MLX_LOAD_FUNCTION(vkQueueSubmit);
MLX_LOAD_FUNCTION(vkResetCommandBuffer);
MLX_LOAD_FUNCTION(vkResetDescriptorPool);
MLX_LOAD_FUNCTION(vkResetEvent);
MLX_LOAD_FUNCTION(vkResetFences);
MLX_LOAD_FUNCTION(vkUpdateDescriptorSets);
MLX_LOAD_FUNCTION(vkWaitForFences);
MLX_LOAD_FUNCTION(vkCreateSwapchainKHR);
MLX_LOAD_FUNCTION(vkDestroySwapchainKHR);
MLX_LOAD_FUNCTION(vkGetSwapchainImagesKHR);
MLX_LOAD_FUNCTION(vkQueuePresentKHR);
kvfPassDeviceVulkanFunctionPointers(m_device, &pfns);
}
#undef MLX_LOAD_FUNCTION
RenderCore::~RenderCore()
{ {
WaitDeviceIdle(); WaitDeviceIdle();
kvfDestroyDevice(m_device); kvfDestroyDevice(m_device);
@@ -93,5 +197,7 @@ namespace mlx
kvfDestroyInstance(m_instance); kvfDestroyInstance(m_instance);
DebugLog("Vulkan : instance destroyed"); DebugLog("Vulkan : instance destroyed");
loader.reset(); loader.reset();
s_instance = nullptr;
} }
} }

4
runtime/Sources/Renderer/RenderPasses/2DPass.cpp
View File

@@ -106,8 +106,8 @@ namespace mlx
sprite->GetTexture()->Update(cmd); sprite->GetTexture()->Update(cmd);
sprite->Bind(frame_index, cmd); sprite->Bind(frame_index, cmd);
std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), sprite->GetSet(frame_index) }; std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), sprite->GetSet(frame_index) };
vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr); mlx::RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data); mlx::RenderCore::Get().vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data);
sprite->GetMesh()->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef()); sprite->GetMesh()->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
} }
m_pipeline.EndPipeline(cmd); m_pipeline.EndPipeline(cmd);

4
runtime/Sources/Renderer/RenderPasses/FinalPass.cpp
View File

@@ -61,8 +61,8 @@ namespace mlx
m_pipeline.BindPipeline(cmd, renderer.GetSwapchainImageIndex(), { 0.0f, 0.0f, 0.0f, 1.0f }); m_pipeline.BindPipeline(cmd, renderer.GetSwapchainImageIndex(), { 0.0f, 0.0f, 0.0f, 1.0f });
VkDescriptorSet set = p_set->GetSet(renderer.GetCurrentFrameIndex()); VkDescriptorSet set = p_set->GetSet(renderer.GetCurrentFrameIndex());
vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, 1, &set, 0, nullptr); RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, 1, &set, 0, nullptr);
vkCmdDraw(cmd, 3, 1, 0, 0); RenderCore::Get().vkCmdDraw(cmd, 3, 1, 0, 0);
renderer.GetDrawCallsCounterRef()++; renderer.GetDrawCallsCounterRef()++;
renderer.GetPolygonDrawnCounterRef()++; renderer.GetPolygonDrawnCounterRef()++;
m_pipeline.EndPipeline(cmd); m_pipeline.EndPipeline(cmd);

8
runtime/Sources/Renderer/Renderer.cpp
View File

@@ -57,7 +57,7 @@ namespace mlx
bool Renderer::BeginFrame() bool Renderer::BeginFrame()
{ {
kvfWaitForFence(RenderCore::Get().GetDevice(), m_cmd_fences[m_current_frame_index]); kvfWaitForFence(RenderCore::Get().GetDevice(), m_cmd_fences[m_current_frame_index]);
VkResult result = vkAcquireNextImageKHR(RenderCore::Get().GetDevice(), m_swapchain, UINT64_MAX, m_image_available_semaphores[m_current_frame_index], VK_NULL_HANDLE, &m_swapchain_image_index); VkResult result = RenderCore::Get().vkAcquireNextImageKHR(RenderCore::Get().GetDevice(), m_swapchain, UINT64_MAX, m_image_available_semaphores[m_current_frame_index], VK_NULL_HANDLE, &m_swapchain_image_index);
if(result == VK_ERROR_OUT_OF_DATE_KHR) if(result == VK_ERROR_OUT_OF_DATE_KHR)
{ {
DestroySwapchain(); DestroySwapchain();
@@ -68,7 +68,7 @@ namespace mlx
else if(result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) else if(result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
FatalError("Vulkan error : failed to acquire swapchain image, %", kvfVerbaliseVkResult(result)); FatalError("Vulkan error : failed to acquire swapchain image, %", kvfVerbaliseVkResult(result));
vkResetCommandBuffer(m_cmd_buffers[m_current_frame_index], 0); RenderCore::Get().vkResetCommandBuffer(m_cmd_buffers[m_current_frame_index], 0);
kvfBeginCommandBuffer(m_cmd_buffers[m_current_frame_index], 0); kvfBeginCommandBuffer(m_cmd_buffers[m_current_frame_index], 0);
m_drawcalls = 0; m_drawcalls = 0;
m_polygons_drawn = 0; m_polygons_drawn = 0;
@@ -102,7 +102,7 @@ namespace mlx
std::uint32_t images_count = kvfGetSwapchainImagesCount(m_swapchain); std::uint32_t images_count = kvfGetSwapchainImagesCount(m_swapchain);
std::vector<VkImage> tmp(images_count); std::vector<VkImage> tmp(images_count);
m_swapchain_images.resize(images_count); m_swapchain_images.resize(images_count);
vkGetSwapchainImagesKHR(RenderCore::Get().GetDevice(), m_swapchain, &images_count, tmp.data()); RenderCore::Get().vkGetSwapchainImagesKHR(RenderCore::Get().GetDevice(), m_swapchain, &images_count, tmp.data());
for(std::size_t i = 0; i < images_count; i++) for(std::size_t i = 0; i < images_count; i++)
{ {
m_swapchain_images[i].Init(tmp[i], kvfGetSwapchainImagesFormat(m_swapchain), extent.width, extent.height); m_swapchain_images[i].Init(tmp[i], kvfGetSwapchainImagesFormat(m_swapchain), extent.width, extent.height);
@@ -136,7 +136,7 @@ namespace mlx
} }
DestroySwapchain(); DestroySwapchain();
vkDestroySurfaceKHR(RenderCore::Get().GetInstance(), m_surface, nullptr); RenderCore::Get().vkDestroySurfaceKHR(RenderCore::Get().GetInstance(), m_surface, nullptr);
DebugLog("Vulkan : surface destroyed"); DebugLog("Vulkan : surface destroyed");
m_surface = VK_NULL_HANDLE; m_surface = VK_NULL_HANDLE;
} }

354
runtime/Sources/Renderer/Vulkan/VulkanLoader.cpp
View File

@@ -1,7 +1,6 @@
#include "Renderer/Vulkan/VulkanPrototypes.h"
#include "vulkan/vulkan_core.h"
#include <PreCompiled.h> #include <PreCompiled.h>
#include <Renderer/Vulkan/VulkanLoader.h> #include <Renderer/Vulkan/VulkanLoader.h>
#include <Renderer/RenderCore.h>
#ifdef MLX_PLAT_WINDOWS #ifdef MLX_PLAT_WINDOWS
__declspec(dllimport) HMODULE __stdcall LoadLibraryA(LPCSTR); __declspec(dllimport) HMODULE __stdcall LoadLibraryA(LPCSTR);
@@ -29,19 +28,19 @@ namespace mlx
{ {
static inline PFN_vkVoidFunction vkGetInstanceProcAddrStub(Handle context, const char* name) static inline PFN_vkVoidFunction vkGetInstanceProcAddrStub(Handle context, const char* name)
{ {
PFN_vkVoidFunction function = vkGetInstanceProcAddr(static_cast<VkInstance>(context), name); PFN_vkVoidFunction function = RenderCore::Get().vkGetInstanceProcAddr(static_cast<VkInstance>(context), name);
if(!function) if(!function)
FatalError("Vulkan loader : could not load '%'", name); FatalError("Vulkan loader : could not load '%'", name);
DebugLog("Vulkan loader : loaded %", name); //DebugLog("Vulkan loader : loaded %", name);
return function; return function;
} }
static inline PFN_vkVoidFunction vkGetDeviceProcAddrStub(Handle context, const char* name) static inline PFN_vkVoidFunction vkGetDeviceProcAddrStub(Handle context, const char* name)
{ {
PFN_vkVoidFunction function = vkGetDeviceProcAddr(static_cast<VkDevice>(context), name); PFN_vkVoidFunction function = RenderCore::Get().vkGetDeviceProcAddr(static_cast<VkDevice>(context), name);
if(!function) if(!function)
FatalError("Vulkan loader : could not load '%'", name); FatalError("Vulkan loader : could not load '%'", name);
DebugLog("Vulkan loader : loaded %", name); //DebugLog("Vulkan loader : loaded %", name);
return function; return function;
} }
@@ -90,19 +89,20 @@ namespace mlx
{ {
p_module = Internal::LoadLib(libname); p_module = Internal::LoadLib(libname);
if(p_module != nullptr) if(p_module != nullptr)
break; {
DISABLE_GCC_PEDANTIC_WARNINGS
RenderCore::Get().vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(Internal::GetSymbol(p_module, "vkGetInstanceProcAddr"));
RESTORE_GCC_PEDANTIC_WARNINGS
if(RenderCore::Get().vkGetInstanceProcAddr)
{
DebugLog("Vulkan loader : libvulkan loaded using '%'", libname);
break;
}
}
} }
if(!p_module) if(!p_module || !RenderCore::Get().vkGetInstanceProcAddr)
FatalError("Vulkan loader : failed to load libvulkan"); FatalError("Vulkan loader : failed to load libvulkan");
LoadGlobalFunctions(nullptr, Internal::vkGetInstanceProcAddrStub);
DISABLE_GCC_PEDANTIC_WARNINGS
vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(Internal::GetSymbol(p_module, "vkGetInstanceProcAddr"));
RESTORE_GCC_PEDANTIC_WARNINGS
if(!vkGetInstanceProcAddr)
FatalError("Vulkan loader : could not get symbol for 'vkGetInstanceProcAddr'");
DebugLog("Vulkan loader : libvulkan loaded");
LoadGlobalFunctions(NULL, Internal::vkGetInstanceProcAddrStub);
} }
void VulkanLoader::LoadInstance(VkInstance instance) void VulkanLoader::LoadInstance(VkInstance instance)
@@ -117,173 +117,25 @@ namespace mlx
void VulkanLoader::LoadGlobalFunctions(void* context, PFN_vkVoidFunction (*load)(void*, const char*)) noexcept void VulkanLoader::LoadGlobalFunctions(void* context, PFN_vkVoidFunction (*load)(void*, const char*)) noexcept
{ {
#ifdef VK_VERSION_1_0 #define MLX_VULKAN_GLOBAL_FUNCTION(fn) RenderCore::Get().fn = reinterpret_cast<PFN_##fn>(load(context, #fn));
vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(load(context, "vkCreateInstance")); #include <Renderer/Vulkan/VulkanDefs.h>
vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(load(context, "vkEnumerateInstanceExtensionProperties")); #undef MLX_VULKAN_GLOBAL_FUNCTION
vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(load(context, "vkEnumerateInstanceLayerProperties"));
#endif
DebugLog("Vulkan loader : global functions loaded"); DebugLog("Vulkan loader : global functions loaded");
} }
void VulkanLoader::LoadInstanceFunctions(void* context, PFN_vkVoidFunction (*load)(void*, const char*)) noexcept void VulkanLoader::LoadInstanceFunctions(void* context, PFN_vkVoidFunction (*load)(void*, const char*)) noexcept
{ {
#ifdef VK_VERSION_1_0 #define MLX_VULKAN_INSTANCE_FUNCTION(fn) RenderCore::Get().fn = reinterpret_cast<PFN_##fn>(load(context, #fn));
vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(load(context, "vkCreateDevice")); #include <Renderer/Vulkan/VulkanDefs.h>
vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(load(context, "vkDestroyInstance")); #undef MLX_VULKAN_INSTANCE_FUNCTION
vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(load(context, "vkEnumerateDeviceExtensionProperties"));
vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(load(context, "vkEnumerateDeviceLayerProperties"));
vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(load(context, "vkEnumeratePhysicalDevices"));
vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(load(context, "vkGetDeviceProcAddr"));
vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(load(context, "vkGetPhysicalDeviceFeatures"));
vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(load(context, "vkGetPhysicalDeviceFormatProperties"));
vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(load(context, "vkGetPhysicalDeviceImageFormatProperties"));
vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(load(context, "vkGetPhysicalDeviceMemoryProperties"));
vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(load(context, "vkGetPhysicalDeviceProperties"));
vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(load(context, "vkGetPhysicalDeviceQueueFamilyProperties"));
vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(load(context, "vkGetPhysicalDeviceSparseImageFormatProperties"));
#endif
#ifdef VK_KHR_surface
vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(load(context, "vkDestroySurfaceKHR"));
vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(load(context, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(load(context, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(load(context, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(load(context, "vkGetPhysicalDeviceSurfaceSupportKHR"));
#endif
DebugLog("Vulkan loader : instance functions loaded"); DebugLog("Vulkan loader : instance functions loaded");
} }
void VulkanLoader::LoadDeviceFunctions(void* context, PFN_vkVoidFunction (*load)(void*, const char*)) noexcept void VulkanLoader::LoadDeviceFunctions(void* context, PFN_vkVoidFunction (*load)(void*, const char*)) noexcept
{ {
#ifdef VK_VERSION_1_0 #define MLX_VULKAN_DEVICE_FUNCTION(fn) RenderCore::Get().fn = reinterpret_cast<PFN_##fn>(load(context, #fn));
vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(load(context, "vkAllocateCommandBuffers")); #include <Renderer/Vulkan/VulkanDefs.h>
vkAllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(load(context, "vkAllocateDescriptorSets")); #undef MLX_VULKAN_DEVICE_FUNCTION
vkAllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(load(context, "vkAllocateMemory"));
vkBeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(load(context, "vkBeginCommandBuffer"));
vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(load(context, "vkBindBufferMemory"));
vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(load(context, "vkBindImageMemory"));
vkCmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(load(context, "vkCmdBeginQuery"));
vkCmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(load(context, "vkCmdBeginRenderPass"));
vkCmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(load(context, "vkCmdBindDescriptorSets"));
vkCmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(load(context, "vkCmdBindIndexBuffer"));
vkCmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(load(context, "vkCmdBindPipeline"));
vkCmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(load(context, "vkCmdBindVertexBuffers"));
vkCmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(load(context, "vkCmdBlitImage"));
vkCmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(load(context, "vkCmdClearAttachments"));
vkCmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(load(context, "vkCmdClearColorImage"));
vkCmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(load(context, "vkCmdClearDepthStencilImage"));
vkCmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(load(context, "vkCmdCopyBuffer"));
vkCmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(load(context, "vkCmdCopyBufferToImage"));
vkCmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(load(context, "vkCmdCopyImage"));
vkCmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(load(context, "vkCmdCopyImageToBuffer"));
vkCmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(load(context, "vkCmdCopyQueryPoolResults"));
vkCmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(load(context, "vkCmdDispatch"));
vkCmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(load(context, "vkCmdDispatchIndirect"));
vkCmdDraw = reinterpret_cast<PFN_vkCmdDraw>(load(context, "vkCmdDraw"));
vkCmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(load(context, "vkCmdDrawIndexed"));
vkCmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(load(context, "vkCmdDrawIndexedIndirect"));
vkCmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(load(context, "vkCmdDrawIndirect"));
vkCmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(load(context, "vkCmdEndQuery"));
vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(load(context, "vkCmdEndRenderPass"));
vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(load(context, "vkCmdExecuteCommands"));
vkCmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(load(context, "vkCmdFillBuffer"));
vkCmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(load(context, "vkCmdNextSubpass"));
vkCmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(load(context, "vkCmdPipelineBarrier"));
vkCmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(load(context, "vkCmdPushConstants"));
vkCmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(load(context, "vkCmdResetEvent"));
vkCmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(load(context, "vkCmdResetQueryPool"));
vkCmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(load(context, "vkCmdResolveImage"));
vkCmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(load(context, "vkCmdSetBlendConstants"));
vkCmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(load(context, "vkCmdSetDepthBias"));
vkCmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(load(context, "vkCmdSetDepthBounds"));
vkCmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(load(context, "vkCmdSetEvent"));
vkCmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(load(context, "vkCmdSetLineWidth"));
vkCmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(load(context, "vkCmdSetScissor"));
vkCmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(load(context, "vkCmdSetStencilCompareMask"));
vkCmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(load(context, "vkCmdSetStencilReference"));
vkCmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(load(context, "vkCmdSetStencilWriteMask"));
vkCmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(load(context, "vkCmdSetViewport"));
vkCmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(load(context, "vkCmdUpdateBuffer"));
vkCmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(load(context, "vkCmdWaitEvents"));
vkCmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(load(context, "vkCmdWriteTimestamp"));
vkCreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(load(context, "vkCreateBuffer"));
vkCreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(load(context, "vkCreateBufferView"));
vkCreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(load(context, "vkCreateCommandPool"));
vkCreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(load(context, "vkCreateComputePipelines"));
vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(load(context, "vkCreateDescriptorPool"));
vkCreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(load(context, "vkCreateDescriptorSetLayout"));
vkCreateEvent = reinterpret_cast<PFN_vkCreateEvent>(load(context, "vkCreateEvent"));
vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(load(context, "vkCreateFence"));
vkCreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(load(context, "vkCreateFramebuffer"));
vkCreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(load(context, "vkCreateGraphicsPipelines"));
vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(load(context, "vkCreateImage"));
vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(load(context, "vkCreateImageView"));
vkCreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(load(context, "vkCreatePipelineCache"));
vkCreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(load(context, "vkCreatePipelineLayout"));
vkCreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(load(context, "vkCreateQueryPool"));
vkCreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(load(context, "vkCreateRenderPass"));
vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(load(context, "vkCreateSampler"));
vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(load(context, "vkCreateSemaphore"));
vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(load(context, "vkCreateShaderModule"));
vkDestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(load(context, "vkDestroyBuffer"));
vkDestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(load(context, "vkDestroyBufferView"));
vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(load(context, "vkDestroyCommandPool"));
vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(load(context, "vkDestroyDescriptorPool"));
vkDestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(load(context, "vkDestroyDescriptorSetLayout"));
vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(load(context, "vkDestroyDevice"));
vkDestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(load(context, "vkDestroyEvent"));
vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(load(context, "vkDestroyFence"));
vkDestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(load(context, "vkDestroyFramebuffer"));
vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(load(context, "vkDestroyImage"));
vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(load(context, "vkDestroyImageView"));
vkDestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(load(context, "vkDestroyPipeline"));
vkDestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(load(context, "vkDestroyPipelineCache"));
vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(load(context, "vkDestroyPipelineLayout"));
vkDestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(load(context, "vkDestroyQueryPool"));
vkDestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(load(context, "vkDestroyRenderPass"));
vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(load(context, "vkDestroySampler"));
vkDestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(load(context, "vkDestroySemaphore"));
vkDestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(load(context, "vkDestroyShaderModule"));
vkDeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(load(context, "vkDeviceWaitIdle"));
vkEndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(load(context, "vkEndCommandBuffer"));
vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(load(context, "vkFlushMappedMemoryRanges"));
vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(load(context, "vkFreeCommandBuffers"));
vkFreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(load(context, "vkFreeDescriptorSets"));
vkFreeMemory = reinterpret_cast<PFN_vkFreeMemory>(load(context, "vkFreeMemory"));
vkGetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(load(context, "vkGetBufferMemoryRequirements"));
vkGetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(load(context, "vkGetDeviceMemoryCommitment"));
vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(load(context, "vkGetDeviceQueue"));
vkGetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(load(context, "vkGetEventStatus"));
vkGetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(load(context, "vkGetFenceStatus"));
vkGetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(load(context, "vkGetImageMemoryRequirements"));
vkGetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(load(context, "vkGetImageSparseMemoryRequirements"));
vkGetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(load(context, "vkGetImageSubresourceLayout"));
vkGetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(load(context, "vkGetPipelineCacheData"));
vkGetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(load(context, "vkGetQueryPoolResults"));
vkGetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(load(context, "vkGetRenderAreaGranularity"));
vkInvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(load(context, "vkInvalidateMappedMemoryRanges"));
vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(load(context, "vkMapMemory"));
vkMergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(load(context, "vkMergePipelineCaches"));
vkQueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(load(context, "vkQueueBindSparse"));
vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(load(context, "vkQueueSubmit"));
vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(load(context, "vkQueueWaitIdle"));
vkResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(load(context, "vkResetCommandBuffer"));
vkResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(load(context, "vkResetCommandPool"));
vkResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(load(context, "vkResetDescriptorPool"));
vkResetEvent = reinterpret_cast<PFN_vkResetEvent>(load(context, "vkResetEvent"));
vkResetFences = reinterpret_cast<PFN_vkResetFences>(load(context, "vkResetFences"));
vkSetEvent = reinterpret_cast<PFN_vkSetEvent>(load(context, "vkSetEvent"));
vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(load(context, "vkUnmapMemory"));
vkUpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(load(context, "vkUpdateDescriptorSets"));
vkWaitForFences = reinterpret_cast<PFN_vkWaitForFences>(load(context, "vkWaitForFences"));
#endif
#ifdef VK_KHR_swapchain
vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(load(context, "vkAcquireNextImageKHR"));
vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(load(context, "vkCreateSwapchainKHR"));
vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(load(context, "vkDestroySwapchainKHR"));
vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(load(context, "vkGetSwapchainImagesKHR"));
vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(load(context, "vkQueuePresentKHR"));
#endif
DebugLog("Vulkan loader : device functions loaded"); DebugLog("Vulkan loader : device functions loaded");
} }
@@ -298,157 +150,3 @@ namespace mlx
DebugLog("Vulkan loader : libvulkan unloaded"); DebugLog("Vulkan loader : libvulkan unloaded");
} }
} }
#ifdef VK_VERSION_1_0
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
PFN_vkAllocateMemory vkAllocateMemory;
PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
PFN_vkBindBufferMemory vkBindBufferMemory;
PFN_vkBindImageMemory vkBindImageMemory;
PFN_vkCmdBeginQuery vkCmdBeginQuery;
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
PFN_vkCmdBindPipeline vkCmdBindPipeline;
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
PFN_vkCmdBlitImage vkCmdBlitImage;
PFN_vkCmdClearAttachments vkCmdClearAttachments;
PFN_vkCmdClearColorImage vkCmdClearColorImage;
PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
PFN_vkCmdCopyImage vkCmdCopyImage;
PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
PFN_vkCmdDispatch vkCmdDispatch;
PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
PFN_vkCmdDraw vkCmdDraw;
PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
PFN_vkCmdEndQuery vkCmdEndQuery;
PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
PFN_vkCmdFillBuffer vkCmdFillBuffer;
PFN_vkCmdNextSubpass vkCmdNextSubpass;
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
PFN_vkCmdPushConstants vkCmdPushConstants;
PFN_vkCmdResetEvent vkCmdResetEvent;
PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
PFN_vkCmdResolveImage vkCmdResolveImage;
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
PFN_vkCmdSetEvent vkCmdSetEvent;
PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
PFN_vkCmdSetScissor vkCmdSetScissor;
PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
PFN_vkCmdSetViewport vkCmdSetViewport;
PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
PFN_vkCmdWaitEvents vkCmdWaitEvents;
PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
PFN_vkCreateBuffer vkCreateBuffer;
PFN_vkCreateBufferView vkCreateBufferView;
PFN_vkCreateCommandPool vkCreateCommandPool;
PFN_vkCreateComputePipelines vkCreateComputePipelines;
PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
PFN_vkCreateDevice vkCreateDevice;
PFN_vkCreateEvent vkCreateEvent;
PFN_vkCreateFence vkCreateFence;
PFN_vkCreateFramebuffer vkCreateFramebuffer;
PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
PFN_vkCreateImage vkCreateImage;
PFN_vkCreateImageView vkCreateImageView;
PFN_vkCreateInstance vkCreateInstance;
PFN_vkCreatePipelineCache vkCreatePipelineCache;
PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
PFN_vkCreateQueryPool vkCreateQueryPool;
PFN_vkCreateRenderPass vkCreateRenderPass;
PFN_vkCreateSampler vkCreateSampler;
PFN_vkCreateSemaphore vkCreateSemaphore;
PFN_vkCreateShaderModule vkCreateShaderModule;
PFN_vkDestroyBuffer vkDestroyBuffer;
PFN_vkDestroyBufferView vkDestroyBufferView;
PFN_vkDestroyCommandPool vkDestroyCommandPool;
PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
PFN_vkDestroyDevice vkDestroyDevice;
PFN_vkDestroyEvent vkDestroyEvent;
PFN_vkDestroyFence vkDestroyFence;
PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
PFN_vkDestroyImage vkDestroyImage;
PFN_vkDestroyImageView vkDestroyImageView;
PFN_vkDestroyInstance vkDestroyInstance;
PFN_vkDestroyPipeline vkDestroyPipeline;
PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
PFN_vkDestroyQueryPool vkDestroyQueryPool;
PFN_vkDestroyRenderPass vkDestroyRenderPass;
PFN_vkDestroySampler vkDestroySampler;
PFN_vkDestroySemaphore vkDestroySemaphore;
PFN_vkDestroyShaderModule vkDestroyShaderModule;
PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
PFN_vkEndCommandBuffer vkEndCommandBuffer;
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
PFN_vkFreeMemory vkFreeMemory;
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
PFN_vkGetDeviceQueue vkGetDeviceQueue;
PFN_vkGetEventStatus vkGetEventStatus;
PFN_vkGetFenceStatus vkGetFenceStatus;
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
PFN_vkMapMemory vkMapMemory;
PFN_vkMergePipelineCaches vkMergePipelineCaches;
PFN_vkQueueBindSparse vkQueueBindSparse;
PFN_vkQueueSubmit vkQueueSubmit;
PFN_vkQueueWaitIdle vkQueueWaitIdle;
PFN_vkResetCommandBuffer vkResetCommandBuffer;
PFN_vkResetCommandPool vkResetCommandPool;
PFN_vkResetDescriptorPool vkResetDescriptorPool;
PFN_vkResetEvent vkResetEvent;
PFN_vkResetFences vkResetFences;
PFN_vkSetEvent vkSetEvent;
PFN_vkUnmapMemory vkUnmapMemory;
PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
PFN_vkWaitForFences vkWaitForFences;
#endif
#ifdef VK_KHR_swapchain
PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
PFN_vkQueuePresentKHR vkQueuePresentKHR;
#endif
#ifdef VK_KHR_surface
PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
#endif

629
third_party/kvf.h vendored
View File

File diff suppressed because it is too large Load Diff