278 lines
9.2 KiB
C++
278 lines
9.2 KiB
C++
#include <SDL2/SDL.h>
|
|
#include <SDL2/SDL_vulkan.h>
|
|
|
|
#include <vector>
|
|
#include <cstdint>
|
|
|
|
#include <Core/Engine.h>
|
|
#include <Platform/Window.h>
|
|
#include <Renderer/Descriptor.h>
|
|
#include <Renderer/RenderCore.h>
|
|
#include <Renderer/Pipelines/Shader.h>
|
|
#include <Renderer/Vulkan/VulkanLoader.h>
|
|
#include <Maths/Mat4.h>
|
|
#include <Core/Logs.h>
|
|
|
|
#define KVF_IMPLEMENTATION
|
|
#ifdef DEBUG
|
|
#define KVF_ENABLE_VALIDATION_LAYERS
|
|
#endif
|
|
#define KVF_ASSERT(x) (Scop::Assert(x, "internal kvf assertion " #x))
|
|
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
|
|
#include <kvf.h>
|
|
#pragma GCC diagnostic pop
|
|
#elif defined(__clang__)
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
|
|
#include <kvf.h>
|
|
#pragma clang diagnostic pop
|
|
#else
|
|
#include <kvf.h>
|
|
#endif
|
|
|
|
namespace Scop
|
|
{
|
|
static std::unique_ptr<VulkanLoader> loader;
|
|
|
|
std::optional<std::uint32_t> FindMemoryType(std::uint32_t type_filter, VkMemoryPropertyFlags properties, bool error)
|
|
{
|
|
VkPhysicalDeviceMemoryProperties mem_properties;
|
|
RenderCore::Get().vkGetPhysicalDeviceMemoryProperties(RenderCore::Get().GetPhysicalDevice(), &mem_properties);
|
|
|
|
for(std::uint32_t i = 0; i < mem_properties.memoryTypeCount; i++)
|
|
{
|
|
if((type_filter & (1 << i)) && (mem_properties.memoryTypes[i].propertyFlags & properties) == properties)
|
|
return i;
|
|
}
|
|
if(error)
|
|
FatalError("Vulkan: failed to find suitable memory type");
|
|
return std::nullopt;
|
|
}
|
|
|
|
void ErrorCallback(const char* message) noexcept
|
|
{
|
|
Logs::Report(LogType::FatalError, 0, "", "", message);
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
void ValidationErrorCallback(const char* message) noexcept
|
|
{
|
|
Logs::Report(LogType::Error, 0, "", "", message);
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
void WarningCallback(const char* message) noexcept
|
|
{
|
|
Logs::Report(LogType::Warning, 0, "", "", message);
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
RenderCore* RenderCore::s_instance = nullptr;
|
|
|
|
RenderCore::RenderCore()
|
|
{
|
|
if(s_instance != nullptr)
|
|
return;
|
|
|
|
s_instance = this;
|
|
|
|
Window window("", 1, 1, true);
|
|
std::vector<const char*> instance_extensions = window.GetRequiredVulkanInstanceExtentions();
|
|
|
|
loader = std::make_unique<VulkanLoader>();
|
|
|
|
LoadKVFGlobalVulkanFunctionPointers();
|
|
|
|
kvfSetErrorCallback(&ErrorCallback);
|
|
kvfSetWarningCallback(&WarningCallback);
|
|
kvfSetValidationErrorCallback(&ValidationErrorCallback);
|
|
kvfSetValidationWarningCallback(&WarningCallback);
|
|
|
|
//kvfAddLayer("VK_LAYER_MESA_overlay");
|
|
|
|
m_instance = kvfCreateInstance(instance_extensions.data(), instance_extensions.size());
|
|
Message("Vulkan: instance created");
|
|
|
|
loader->LoadInstance(m_instance);
|
|
LoadKVFInstanceVulkanFunctionPointers();
|
|
|
|
VkSurfaceKHR surface = window.CreateVulkanSurface(m_instance);
|
|
|
|
m_physical_device = kvfPickGoodDefaultPhysicalDevice(m_instance, surface);
|
|
|
|
// just for style
|
|
VkPhysicalDeviceProperties props;
|
|
vkGetPhysicalDeviceProperties(m_physical_device, &props);
|
|
Message("Vulkan: physical device picked '%'", props.deviceName);
|
|
|
|
const char* device_extensions[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
|
|
VkPhysicalDeviceFeatures features{};
|
|
vkGetPhysicalDeviceFeatures(m_physical_device, &features);
|
|
m_device = kvfCreateDevice(m_physical_device, device_extensions, sizeof(device_extensions) / sizeof(device_extensions[0]), &features);
|
|
Message("Vulkan: logical device created");
|
|
|
|
loader->LoadDevice(m_device);
|
|
LoadKVFDeviceVulkanFunctionPointers();
|
|
|
|
vkDestroySurfaceKHR(m_instance, surface, nullptr);
|
|
|
|
m_allocator.AttachToDevice(m_device, m_physical_device);
|
|
|
|
p_descriptor_pool_manager = std::make_unique<DescriptorPoolManager>();
|
|
|
|
ShaderLayout vertex_shader_layout(
|
|
{
|
|
{ 0,
|
|
ShaderSetLayout({
|
|
{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
|
|
})
|
|
}
|
|
}, { ShaderPushConstantLayout({ 0, sizeof(Mat4f) * 2 }) }
|
|
);
|
|
m_internal_shaders[DEFAULT_VERTEX_SHADER_ID] = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ForwardVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
|
|
|
|
ShaderLayout default_fragment_shader_layout(
|
|
{
|
|
{ 1,
|
|
ShaderSetLayout({
|
|
{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER },
|
|
{ 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
|
|
})
|
|
}
|
|
}, {}
|
|
);
|
|
m_internal_shaders[DEFAULT_FRAGMENT_SHADER_ID] = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ForwardDefaultFragment.spv", ShaderType::Fragment, std::move(default_fragment_shader_layout));
|
|
|
|
ShaderLayout basic_fragment_shader_layout(
|
|
{
|
|
{ 1,
|
|
ShaderSetLayout({
|
|
{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER },
|
|
{ 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
|
|
})
|
|
}
|
|
}, {}
|
|
);
|
|
m_internal_shaders[BASIC_FRAGMENT_SHADER_ID] = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ForwardBasicFragment.spv", ShaderType::Fragment, std::move(basic_fragment_shader_layout));
|
|
}
|
|
|
|
#undef SCOP_LOAD_FUNCTION
|
|
#define SCOP_LOAD_FUNCTION(fn) pfns.fn = this->fn
|
|
|
|
void RenderCore::LoadKVFGlobalVulkanFunctionPointers() const noexcept
|
|
{
|
|
KvfGlobalVulkanFunctions pfns;
|
|
SCOP_LOAD_FUNCTION(vkCreateInstance);
|
|
SCOP_LOAD_FUNCTION(vkEnumerateInstanceExtensionProperties);
|
|
SCOP_LOAD_FUNCTION(vkEnumerateInstanceLayerProperties);
|
|
SCOP_LOAD_FUNCTION(vkGetInstanceProcAddr);
|
|
kvfPassGlobalVulkanFunctionPointers(&pfns);
|
|
}
|
|
|
|
void RenderCore::LoadKVFInstanceVulkanFunctionPointers() const noexcept
|
|
{
|
|
KvfInstanceVulkanFunctions pfns;
|
|
SCOP_LOAD_FUNCTION(vkCreateDevice);
|
|
SCOP_LOAD_FUNCTION(vkDestroyInstance);
|
|
SCOP_LOAD_FUNCTION(vkEnumerateDeviceExtensionProperties);
|
|
SCOP_LOAD_FUNCTION(vkEnumeratePhysicalDevices);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceFeatures);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceFormatProperties);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceImageFormatProperties);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceMemoryProperties);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceProperties);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties);
|
|
SCOP_LOAD_FUNCTION(vkDestroySurfaceKHR);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR);
|
|
SCOP_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR);
|
|
kvfPassInstanceVulkanFunctionPointers(&pfns);
|
|
}
|
|
|
|
void RenderCore::LoadKVFDeviceVulkanFunctionPointers() const noexcept
|
|
{
|
|
KvfDeviceVulkanFunctions pfns;
|
|
SCOP_LOAD_FUNCTION(vkAllocateCommandBuffers);
|
|
SCOP_LOAD_FUNCTION(vkAllocateDescriptorSets);
|
|
SCOP_LOAD_FUNCTION(vkBeginCommandBuffer);
|
|
SCOP_LOAD_FUNCTION(vkCmdBeginRenderPass);
|
|
SCOP_LOAD_FUNCTION(vkCmdCopyBuffer);
|
|
SCOP_LOAD_FUNCTION(vkCmdCopyBufferToImage);
|
|
SCOP_LOAD_FUNCTION(vkCmdCopyImage);
|
|
SCOP_LOAD_FUNCTION(vkCmdCopyImageToBuffer);
|
|
SCOP_LOAD_FUNCTION(vkCmdEndRenderPass);
|
|
SCOP_LOAD_FUNCTION(vkCmdPipelineBarrier);
|
|
SCOP_LOAD_FUNCTION(vkCreateBuffer);
|
|
SCOP_LOAD_FUNCTION(vkCreateCommandPool);
|
|
SCOP_LOAD_FUNCTION(vkCreateDescriptorPool);
|
|
SCOP_LOAD_FUNCTION(vkCreateDescriptorSetLayout);
|
|
SCOP_LOAD_FUNCTION(vkCreateFence);
|
|
SCOP_LOAD_FUNCTION(vkCreateFramebuffer);
|
|
SCOP_LOAD_FUNCTION(vkCreateGraphicsPipelines);
|
|
SCOP_LOAD_FUNCTION(vkCreateImage);
|
|
SCOP_LOAD_FUNCTION(vkCreateImageView);
|
|
SCOP_LOAD_FUNCTION(vkCreatePipelineLayout);
|
|
SCOP_LOAD_FUNCTION(vkCreateRenderPass);
|
|
SCOP_LOAD_FUNCTION(vkCreateSampler);
|
|
SCOP_LOAD_FUNCTION(vkCreateSemaphore);
|
|
SCOP_LOAD_FUNCTION(vkCreateShaderModule);
|
|
SCOP_LOAD_FUNCTION(vkDestroyBuffer);
|
|
SCOP_LOAD_FUNCTION(vkDestroyCommandPool);
|
|
SCOP_LOAD_FUNCTION(vkDestroyDescriptorPool);
|
|
SCOP_LOAD_FUNCTION(vkDestroyDescriptorSetLayout);
|
|
SCOP_LOAD_FUNCTION(vkDestroyDevice);
|
|
SCOP_LOAD_FUNCTION(vkDestroyFence);
|
|
SCOP_LOAD_FUNCTION(vkDestroyFramebuffer);
|
|
SCOP_LOAD_FUNCTION(vkDestroyImage);
|
|
SCOP_LOAD_FUNCTION(vkDestroyImageView);
|
|
SCOP_LOAD_FUNCTION(vkDestroyPipeline);
|
|
SCOP_LOAD_FUNCTION(vkDestroyPipelineLayout);
|
|
SCOP_LOAD_FUNCTION(vkDestroyRenderPass);
|
|
SCOP_LOAD_FUNCTION(vkDestroySampler);
|
|
SCOP_LOAD_FUNCTION(vkDestroySemaphore);
|
|
SCOP_LOAD_FUNCTION(vkDestroyShaderModule);
|
|
SCOP_LOAD_FUNCTION(vkDeviceWaitIdle);
|
|
SCOP_LOAD_FUNCTION(vkEndCommandBuffer);
|
|
SCOP_LOAD_FUNCTION(vkFreeCommandBuffers);
|
|
SCOP_LOAD_FUNCTION(vkGetDeviceQueue);
|
|
SCOP_LOAD_FUNCTION(vkGetImageSubresourceLayout);
|
|
SCOP_LOAD_FUNCTION(vkQueueSubmit);
|
|
SCOP_LOAD_FUNCTION(vkResetCommandBuffer);
|
|
SCOP_LOAD_FUNCTION(vkResetDescriptorPool);
|
|
SCOP_LOAD_FUNCTION(vkResetEvent);
|
|
SCOP_LOAD_FUNCTION(vkResetFences);
|
|
SCOP_LOAD_FUNCTION(vkUpdateDescriptorSets);
|
|
SCOP_LOAD_FUNCTION(vkWaitForFences);
|
|
SCOP_LOAD_FUNCTION(vkCreateSwapchainKHR);
|
|
SCOP_LOAD_FUNCTION(vkDestroySwapchainKHR);
|
|
SCOP_LOAD_FUNCTION(vkGetSwapchainImagesKHR);
|
|
SCOP_LOAD_FUNCTION(vkQueuePresentKHR);
|
|
kvfPassDeviceVulkanFunctionPointers(m_physical_device, m_device, &pfns);
|
|
}
|
|
|
|
#undef SCOP_LOAD_FUNCTION
|
|
|
|
RenderCore::~RenderCore()
|
|
{
|
|
if(s_instance == nullptr)
|
|
return;
|
|
WaitDeviceIdle();
|
|
p_descriptor_pool_manager->Destroy();
|
|
p_descriptor_pool_manager.reset();
|
|
m_allocator.DetachFromDevice();
|
|
for(auto shader: m_internal_shaders)
|
|
shader->Destroy();
|
|
kvfDestroyDevice(m_device);
|
|
Message("Vulkan: logical device destroyed");
|
|
kvfDestroyInstance(m_instance);
|
|
Message("Vulkan: instance destroyed");
|
|
loader.reset();
|
|
|
|
s_instance = nullptr;
|
|
}
|
|
}
|