redstrate/novus
1
Fork 0
mirror of https://github.com/redstrate/Novus.git synced 2025-04-26 05:37:46 +00:00
Code Activity

renderer: Reformat code, misc cleanup

Browse source
This commit is contained in:
Joshua Goins 2023-10-12 23:45:45 -04:00
parent 22ec76c6b4
commit 9d6f06bf1f
2 changed files with 212 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
renderer/include/renderer.hpp
View file

@ -28,10 +28,7 @@ struct RenderTexture {
VkSampler sampler = VK_NULL_HANDLE; VkSampler sampler = VK_NULL_HANDLE;
}; };
enum class MaterialType { enum class MaterialType { Object, Skin };
Object,
Skin
};
struct RenderMaterial { struct RenderMaterial {
MaterialType type = MaterialType::Object; MaterialType type = MaterialType::Object;
@ -57,7 +54,8 @@ struct RenderModel {
class ImGuiPass; class ImGuiPass;
struct ImGuiContext; struct ImGuiContext;
class Renderer { class Renderer
{
public: public:
Renderer(); Renderer();
@ -118,9 +116,13 @@ public:
void endSingleTimeCommands(VkCommandBuffer pT); void endSingleTimeCommands(VkCommandBuffer pT);
void inlineTransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkFormat format, void inlineTransitionImageLayout(VkCommandBuffer commandBuffer,
VkImageAspectFlags aspect, VkImageSubresourceRange range, VkImage image,
VkImageLayout oldLayout, VkImageLayout newLayout, VkFormat format,
VkImageAspectFlags aspect,
VkImageSubresourceRange range,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags src_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VkPipelineStageFlags src_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VkPipelineStageFlags dst_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); VkPipelineStageFlags dst_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);

259
renderer/src/renderer.cpp
View file

@ -16,15 +16,14 @@
#include "imgui.h" #include "imgui.h"
#include "imguipass.h" #include "imguipass.h"
VkResult CreateDebugUtilsMessengerEXT( VkResult CreateDebugUtilsMessengerEXT(VkInstance instance,
VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator, const VkAllocationCallbacks *pAllocator,
VkDebugUtilsMessengerEXT* pCallback) { VkDebugUtilsMessengerEXT *pCallback)
{
// Note: It seems that static_cast<...> doesn't work. Use the C-style forced // Note: It seems that static_cast<...> doesn't work. Use the C-style forced
// cast. // cast.
auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr( auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
instance, "vkCreateDebugUtilsMessengerEXT");
if (func != nullptr) { if (func != nullptr) {
return func(instance, pCreateInfo, pAllocator, pCallback); return func(instance, pCreateInfo, pAllocator, pCallback);
} else { } else {
@ -32,17 +31,18 @@ VkResult CreateDebugUtilsMessengerEXT(
} }
} }
VKAPI_ATTR VkBool32 VKAPI_CALL VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageType, VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
void* pUserData) { void *pUserData)
{
qInfo() << pCallbackData->pMessage; qInfo() << pCallbackData->pMessage;
return VK_FALSE; return VK_FALSE;
} }
Renderer::Renderer() { Renderer::Renderer()
{
Q_INIT_RESOURCE(shaders); Q_INIT_RESOURCE(shaders);
ctx = ImGui::CreateContext(); ctx = ImGui::CreateContext();
@ -73,13 +73,9 @@ Renderer::Renderer() {
} }
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {}; VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {};
debugCreateInfo.sType = debugCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; debugCreateInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
debugCreateInfo.messageSeverity = debugCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
debugCreateInfo.messageType =
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
debugCreateInfo.pfnUserCallback = DebugCallback; debugCreateInfo.pfnUserCallback = DebugCallback;
VkInstanceCreateInfo createInfo = {}; VkInstanceCreateInfo createInfo = {};
@ -91,8 +87,7 @@ Renderer::Renderer() {
vkCreateInstance(&createInfo, nullptr, &instance); vkCreateInstance(&createInfo, nullptr, &instance);
VkDebugUtilsMessengerEXT callback; VkDebugUtilsMessengerEXT callback;
CreateDebugUtilsMessengerEXT(instance, &debugCreateInfo, nullptr, CreateDebugUtilsMessengerEXT(instance, &debugCreateInfo, nullptr, &callback);
&callback);
// pick physical device // pick physical device
uint32_t deviceCount = 0; uint32_t deviceCount = 0;
@ -116,12 +111,10 @@ Renderer::Renderer() {
physicalDevice = devices[preferredDevice]; physicalDevice = devices[preferredDevice];
extensionCount = 0; extensionCount = 0;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
&extensionCount, nullptr);
std::vector<VkExtensionProperties> extensionProperties(extensionCount); std::vector<VkExtensionProperties> extensionProperties(extensionCount);
vkEnumerateDeviceExtensionProperties( vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, extensionProperties.data());
physicalDevice, nullptr, &extensionCount, extensionProperties.data());
// we want to choose the portability subset on platforms that // we want to choose the portability subset on platforms that
// support it, this is a requirement of the portability spec // support it, this is a requirement of the portability spec
@ -135,17 +128,14 @@ Renderer::Renderer() {
// create logical device // create logical device
uint32_t queueFamilyCount = 0; uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount); std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
queueFamilies.data());
int i = 0; int i = 0;
for (const auto &queueFamily : queueFamilies) { for (const auto &queueFamily : queueFamilies) {
if (queueFamily.queueCount > 0 && if (queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
graphicsFamilyIndex = i; graphicsFamilyIndex = i;
} }
@ -195,8 +185,7 @@ Renderer::Renderer() {
VkDeviceCreateInfo deviceCeateInfo = {}; VkDeviceCreateInfo deviceCeateInfo = {};
deviceCeateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; deviceCeateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCeateInfo.pQueueCreateInfos = queueCreateInfos.data(); deviceCeateInfo.pQueueCreateInfos = queueCreateInfos.data();
deviceCeateInfo.queueCreateInfoCount = deviceCeateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
static_cast<uint32_t>(queueCreateInfos.size());
deviceCeateInfo.ppEnabledExtensionNames = deviceExtensions.data(); deviceCeateInfo.ppEnabledExtensionNames = deviceExtensions.data();
deviceCeateInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()); deviceCeateInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
@ -221,7 +210,8 @@ Renderer::Renderer() {
qInfo() << "Initialized renderer!"; qInfo() << "Initialized renderer!";
} }
bool Renderer::initSwapchain(VkSurfaceKHR surface, int width, int height) { bool Renderer::initSwapchain(VkSurfaceKHR surface, int width, int height)
{
vkQueueWaitIdle(presentQueue); vkQueueWaitIdle(presentQueue);
if (width == 0 || height == 0) if (width == 0 || height == 0)
@ -229,39 +219,31 @@ bool Renderer::initSwapchain(VkSurfaceKHR surface, int width, int height) {
// TODO: fix this pls // TODO: fix this pls
VkBool32 supported; VkBool32 supported;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, 0, vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, 0, surface, &supported);
surface, &supported);
// query swapchain support // query swapchain support
VkSurfaceCapabilitiesKHR capabilities; VkSurfaceCapabilitiesKHR capabilities;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &capabilities);
physicalDevice, surface, &capabilities);
std::vector<VkSurfaceFormatKHR> formats; std::vector<VkSurfaceFormatKHR> formats;
uint32_t formatCount; uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formatCount, nullptr);
physicalDevice, surface, &formatCount, nullptr);
formats.resize(formatCount); formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formatCount, formats.data());
physicalDevice, surface, &formatCount, formats.data());
std::vector<VkPresentModeKHR> presentModes; std::vector<VkPresentModeKHR> presentModes;
uint32_t presentModeCount; uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &presentModeCount, nullptr);
physicalDevice, surface, &presentModeCount, nullptr);
presentModes.resize(presentModeCount); presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &presentModeCount, presentModes.data());
physicalDevice, surface, &presentModeCount,
presentModes.data());
// choosing swapchain features // choosing swapchain features
VkSurfaceFormatKHR swapchainSurfaceFormat = formats[0]; VkSurfaceFormatKHR swapchainSurfaceFormat = formats[0];
for (const auto &availableFormat : formats) { for (const auto &availableFormat : formats) {
if (availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM && if (availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
swapchainSurfaceFormat = availableFormat; swapchainSurfaceFormat = availableFormat;
} }
} }
@ -274,8 +256,7 @@ bool Renderer::initSwapchain(VkSurfaceKHR surface, int width, int height) {
} }
uint32_t imageCount = capabilities.minImageCount + 1; uint32_t imageCount = capabilities.minImageCount + 1;
if (capabilities.maxImageCount > 0 && if (capabilities.maxImageCount > 0 && imageCount > capabilities.maxImageCount) {
imageCount > capabilities.maxImageCount) {
imageCount = capabilities.maxImageCount; imageCount = capabilities.maxImageCount;
} }
@ -307,8 +288,7 @@ bool Renderer::initSwapchain(VkSurfaceKHR surface, int width, int height) {
swapchainExtent.width = width; swapchainExtent.width = width;
swapchainExtent.height = height; swapchainExtent.height = height;
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
nullptr);
swapchainImages.resize(imageCount); swapchainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapchainImages.data()); vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapchainImages.data());
@ -441,22 +421,18 @@ bool Renderer::initSwapchain(VkSurfaceKHR surface, int width, int height) {
return true; return true;
} }
void Renderer::resize(VkSurfaceKHR surface, int width, int height) { void Renderer::resize(VkSurfaceKHR surface, int width, int height)
{
initSwapchain(surface, width, height); initSwapchain(surface, width, height);
} }
void Renderer::render(std::vector<RenderModel> models) { void Renderer::render(std::vector<RenderModel> models)
vkWaitForFences( {
device, 1, vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, std::numeric_limits<uint64_t>::max());
&inFlightFences[currentFrame],
VK_TRUE, std::numeric_limits<uint64_t>::max());
uint32_t imageIndex = 0; uint32_t imageIndex = 0;
VkResult result = vkAcquireNextImageKHR( VkResult result =
device, swapchain, vkAcquireNextImageKHR(device, swapchain, std::numeric_limits<uint64_t>::max(), imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
std::numeric_limits<uint64_t>::max(),
imageAvailableSemaphores[currentFrame],
VK_NULL_HANDLE, &imageIndex);
if (result == VK_ERROR_OUT_OF_DATE_KHR) { if (result == VK_ERROR_OUT_OF_DATE_KHR) {
return; return;
@ -533,8 +509,7 @@ void Renderer::render(std::vector<RenderModel> models) {
vkCmdBindVertexBuffers(commandBuffer, 0, 1, &part.vertexBuffer, offsets); vkCmdBindVertexBuffers(commandBuffer, 0, 1, &part.vertexBuffer, offsets);
vkCmdBindIndexBuffer(commandBuffer, part.indexBuffer, 0, VK_INDEX_TYPE_UINT16); vkCmdBindIndexBuffer(commandBuffer, part.indexBuffer, 0, VK_INDEX_TYPE_UINT16);
glm::mat4 p = glm::perspective(glm::radians(45.0f), swapchainExtent.width / (float) swapchainExtent.height, glm::mat4 p = glm::perspective(glm::radians(45.0f), swapchainExtent.width / (float)swapchainExtent.height, 0.1f, 100.0f);
0.1f, 100.0f);
glm::mat4 v = view; glm::mat4 v = view;
glm::mat4 vp = p * v; glm::mat4 vp = p * v;
@ -542,13 +517,28 @@ void Renderer::render(std::vector<RenderModel> models) {
glm::mat4 m = glm::mat4(1.0f); glm::mat4 m = glm::mat4(1.0f);
vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(glm::mat4), sizeof(glm::mat4), &m); vkCmdPushConstants(commandBuffer,
pipelineLayout,
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
sizeof(glm::mat4),
sizeof(glm::mat4),
&m);
int test = 0; int test = 0;
vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(glm::mat4) * 2, sizeof(int), &test); vkCmdPushConstants(commandBuffer,
pipelineLayout,
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
sizeof(glm::mat4) * 2,
sizeof(int),
&test);
int type = (int)material.type; int type = (int)material.type;
vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(glm::mat4) * 2 + sizeof(int), sizeof(int), &type); vkCmdPushConstants(commandBuffer,
pipelineLayout,
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
sizeof(glm::mat4) * 2 + sizeof(int),
sizeof(int),
&type);
vkCmdDrawIndexed(commandBuffer, part.numIndices, 1, 0, 0, 0); vkCmdDrawIndexed(commandBuffer, part.numIndices, 1, 0, 0, 0);
} }
@ -566,8 +556,7 @@ void Renderer::render(std::vector<RenderModel> models) {
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]}; VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]};
VkPipelineStageFlags waitStages[] = { VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
submitInfo.waitSemaphoreCount = 1; submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = waitSemaphores; submitInfo.pWaitSemaphores = waitSemaphores;
submitInfo.pWaitDstStageMask = waitStages; submitInfo.pWaitDstStageMask = waitStages;
@ -599,7 +588,8 @@ void Renderer::render(std::vector<RenderModel> models) {
currentFrame = (currentFrame + 1) % 3; currentFrame = (currentFrame + 1) % 3;
} }
std::tuple<VkBuffer, VkDeviceMemory> Renderer::createBuffer(size_t size, VkBufferUsageFlags usageFlags) { std::tuple<VkBuffer, VkDeviceMemory> Renderer::createBuffer(size_t size, VkBufferUsageFlags usageFlags)
{
vkDeviceWaitIdle(device); vkDeviceWaitIdle(device);
// create buffer // create buffer
@ -619,10 +609,7 @@ std::tuple<VkBuffer, VkDeviceMemory> Renderer::createBuffer(size_t size, VkBuffe
VkMemoryAllocateInfo allocInfo = {}; VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size; allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
findMemoryType(memRequirements.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
VkDeviceMemory memory; VkDeviceMemory memory;
vkAllocateMemory(device, &allocInfo, nullptr, &memory); vkAllocateMemory(device, &allocInfo, nullptr, &memory);
@ -632,14 +619,13 @@ std::tuple<VkBuffer, VkDeviceMemory> Renderer::createBuffer(size_t size, VkBuffe
return {handle, memory}; return {handle, memory};
} }
uint32_t Renderer::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) { uint32_t Renderer::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties)
{
VkPhysicalDeviceMemoryProperties memProperties; VkPhysicalDeviceMemoryProperties memProperties;
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties); vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) { for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
if ((typeFilter & (1 << i)) && if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
(memProperties.memoryTypes[i].propertyFlags & properties) ==
properties) {
return i; return i;
} }
} }
@ -647,7 +633,8 @@ uint32_t Renderer::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags pro
return -1; return -1;
} }
RenderModel Renderer::addModel(const physis_MDL& model, int lod) { RenderModel Renderer::addModel(const physis_MDL &model, int lod)
{
RenderModel renderModel; RenderModel renderModel;
renderModel.model = model; renderModel.model = model;
@ -719,7 +706,8 @@ RenderModel Renderer::addModel(const physis_MDL& model, int lod) {
return renderModel; return renderModel;
} }
void Renderer::initPipeline() { void Renderer::initPipeline()
{
VkPipelineShaderStageCreateInfo vertexShaderStageInfo = {}; VkPipelineShaderStageCreateInfo vertexShaderStageInfo = {};
vertexShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; vertexShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertexShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; vertexShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
@ -848,7 +836,8 @@ void Renderer::initPipeline() {
vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &createInfo, nullptr, &pipeline); vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &createInfo, nullptr, &pipeline);
} }
VkShaderModule Renderer::createShaderModule(const uint32_t* code, const int length) { VkShaderModule Renderer::createShaderModule(const uint32_t *code, const int length)
{
VkShaderModuleCreateInfo createInfo = {}; VkShaderModuleCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = length; createInfo.codeSize = length;
@ -860,7 +849,8 @@ VkShaderModule Renderer::createShaderModule(const uint32_t* code, const int leng
return shaderModule; return shaderModule;
} }
VkShaderModule Renderer::loadShaderFromDisk(const std::string_view path) { VkShaderModule Renderer::loadShaderFromDisk(const std::string_view path)
{
QFile file((QLatin1String(path))); QFile file((QLatin1String(path)));
file.open(QFile::ReadOnly); file.open(QFile::ReadOnly);
@ -872,7 +862,8 @@ VkShaderModule Renderer::loadShaderFromDisk(const std::string_view path) {
return createShaderModule(reinterpret_cast<const uint32_t *>(contents.data()), contents.size()); return createShaderModule(reinterpret_cast<const uint32_t *>(contents.data()), contents.size());
} }
void Renderer::initDescriptors() { void Renderer::initDescriptors()
{
VkDescriptorPoolSize poolSize = {}; VkDescriptorPoolSize poolSize = {};
poolSize.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; poolSize.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSize.descriptorCount = 150; poolSize.descriptorCount = 150;
@ -931,7 +922,8 @@ void Renderer::initDescriptors() {
vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &setLayout); vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &setLayout);
} }
void Renderer::initDepth(int width, int height) { void Renderer::initDepth(int width, int height)
{
VkImageCreateInfo imageCreateInfo = {}; VkImageCreateInfo imageCreateInfo = {};
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D; imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
@ -973,7 +965,8 @@ void Renderer::initDepth(int width, int height) {
vkCreateImageView(device, &viewCreateInfo, nullptr, &depthView); vkCreateImageView(device, &viewCreateInfo, nullptr, &depthView);
} }
RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height, const uint8_t* data, const uint32_t data_size) { RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height, const uint8_t *data, const uint32_t data_size)
{
RenderTexture newTexture = {}; RenderTexture newTexture = {};
VkImageCreateInfo imageInfo = {}; VkImageCreateInfo imageInfo = {};
@ -999,8 +992,7 @@ RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height,
VkMemoryAllocateInfo allocInfo = {}; VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size; allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType( allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkAllocateMemory(device, &allocInfo, nullptr, &newTexture.memory); vkAllocateMemory(device, &allocInfo, nullptr, &newTexture.memory);
@ -1024,10 +1016,7 @@ RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height,
allocInfo = {}; allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size; allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
findMemoryType(memRequirements.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkAllocateMemory(device, &allocInfo, nullptr, &stagingBufferMemory); vkAllocateMemory(device, &allocInfo, nullptr, &stagingBufferMemory);
@ -1048,9 +1037,12 @@ RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height,
range.baseArrayLayer = 0; range.baseArrayLayer = 0;
range.layerCount = 1; range.layerCount = 1;
inlineTransitionImageLayout(commandBuffer, newTexture.handle, inlineTransitionImageLayout(commandBuffer,
imageInfo.format, VK_IMAGE_ASPECT_COLOR_BIT, newTexture.handle,
range, VK_IMAGE_LAYOUT_UNDEFINED, imageInfo.format,
VK_IMAGE_ASPECT_COLOR_BIT,
range,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkBufferImageCopy region = {}; VkBufferImageCopy region = {};
@ -1058,15 +1050,16 @@ RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height,
region.imageSubresource.mipLevel = 0; region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0; region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1; region.imageSubresource.layerCount = 1;
region.imageExtent = {(uint32_t)width, region.imageExtent = {(uint32_t)width, (uint32_t)height, 1};
(uint32_t)height, 1};
vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, newTexture.handle, vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, newTexture.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
inlineTransitionImageLayout(commandBuffer, newTexture.handle, inlineTransitionImageLayout(commandBuffer,
imageInfo.format, VK_IMAGE_ASPECT_COLOR_BIT, newTexture.handle,
range, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, imageInfo.format,
VK_IMAGE_ASPECT_COLOR_BIT,
range,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
endSingleTimeCommands(commandBuffer); endSingleTimeCommands(commandBuffer);
@ -1100,7 +1093,8 @@ RenderTexture Renderer::addTexture(const uint32_t width, const uint32_t height,
return newTexture; return newTexture;
} }
VkCommandBuffer Renderer::beginSingleTimeCommands() { VkCommandBuffer Renderer::beginSingleTimeCommands()
{
VkCommandBufferAllocateInfo allocInfo = {}; VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
@ -1119,7 +1113,8 @@ VkCommandBuffer Renderer::beginSingleTimeCommands() {
return commandBuffer; return commandBuffer;
} }
void Renderer::endSingleTimeCommands(VkCommandBuffer commandBuffer) { void Renderer::endSingleTimeCommands(VkCommandBuffer commandBuffer)
{
vkEndCommandBuffer(commandBuffer); vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo = {}; VkSubmitInfo submitInfo = {};
@ -1133,10 +1128,16 @@ void Renderer::endSingleTimeCommands(VkCommandBuffer commandBuffer) {
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
} }
void Renderer::inlineTransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkFormat format, void Renderer::inlineTransitionImageLayout(VkCommandBuffer commandBuffer,
VkImageAspectFlags aspect, VkImageSubresourceRange range, VkImage image,
VkImageLayout oldLayout, VkImageLayout newLayout, VkFormat format,
VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask) { VkImageAspectFlags aspect,
VkImageSubresourceRange range,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags src_stage_mask,
VkPipelineStageFlags dst_stage_mask)
{
VkImageMemoryBarrier barrier = {}; VkImageMemoryBarrier barrier = {};
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.oldLayout = oldLayout; barrier.oldLayout = oldLayout;
@ -1178,11 +1179,11 @@ void Renderer::inlineTransitionImageLayout(VkCommandBuffer commandBuffer, VkImag
break; break;
} }
vkCmdPipelineBarrier(commandBuffer, src_stage_mask, dst_stage_mask, 0, 0, vkCmdPipelineBarrier(commandBuffer, src_stage_mask, dst_stage_mask, 0, 0, nullptr, 0, nullptr, 1, &barrier);
nullptr, 0, nullptr, 1, &barrier);
} }
uint64_t Renderer::hash(const RenderModel& model, const RenderMaterial& material) { uint64_t Renderer::hash(const RenderModel &model, const RenderMaterial &material)
{
uint64_t hash = 0; uint64_t hash = 0;
hash += reinterpret_cast<intptr_t>((void *)&model); hash += reinterpret_cast<intptr_t>((void *)&model);
if (material.diffuseTexture) if (material.diffuseTexture)
@ -1196,7 +1197,8 @@ uint64_t Renderer::hash(const RenderModel& model, const RenderMaterial& material
return hash; return hash;
} }
VkDescriptorSet Renderer::createDescriptorFor(const RenderModel& model, const RenderMaterial& material) { VkDescriptorSet Renderer::createDescriptorFor(const RenderModel &model, const RenderMaterial &material)
{
VkDescriptorSet set; VkDescriptorSet set;
VkDescriptorSetAllocateInfo allocateInfo = {}; VkDescriptorSetAllocateInfo allocateInfo = {};
@ -1309,7 +1311,8 @@ VkDescriptorSet Renderer::createDescriptorFor(const RenderModel& model, const Re
return set; return set;
} }
void Renderer::createDummyTexture() { void Renderer::createDummyTexture()
{
VkImageCreateInfo imageInfo = {}; VkImageCreateInfo imageInfo = {};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D; imageInfo.imageType = VK_IMAGE_TYPE_2D;
@ -1333,8 +1336,7 @@ void Renderer::createDummyTexture() {
VkMemoryAllocateInfo allocInfo = {}; VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size; allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType( allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkAllocateMemory(device, &allocInfo, nullptr, &dummyMemory); vkAllocateMemory(device, &allocInfo, nullptr, &dummyMemory);
@ -1358,10 +1360,7 @@ void Renderer::createDummyTexture() {
allocInfo = {}; allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size; allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
findMemoryType(memRequirements.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkAllocateMemory(device, &allocInfo, nullptr, &stagingBufferMemory); vkAllocateMemory(device, &allocInfo, nullptr, &stagingBufferMemory);
@ -1384,9 +1383,12 @@ void Renderer::createDummyTexture() {
range.baseArrayLayer = 0; range.baseArrayLayer = 0;
range.layerCount = 1; range.layerCount = 1;
inlineTransitionImageLayout(commandBuffer, dummyImage, inlineTransitionImageLayout(commandBuffer,
imageInfo.format, VK_IMAGE_ASPECT_COLOR_BIT, dummyImage,
range, VK_IMAGE_LAYOUT_UNDEFINED, imageInfo.format,
VK_IMAGE_ASPECT_COLOR_BIT,
range,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkBufferImageCopy region = {}; VkBufferImageCopy region = {};
@ -1394,15 +1396,16 @@ void Renderer::createDummyTexture() {
region.imageSubresource.mipLevel = 0; region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0; region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1; region.imageSubresource.layerCount = 1;
region.imageExtent = {(uint32_t)1, region.imageExtent = {(uint32_t)1, (uint32_t)1, 1};
(uint32_t)1, 1};
vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, dummyImage, vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, dummyImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
inlineTransitionImageLayout(commandBuffer, dummyImage, inlineTransitionImageLayout(commandBuffer,
imageInfo.format, VK_IMAGE_ASPECT_COLOR_BIT, dummyImage,
range, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, imageInfo.format,
VK_IMAGE_ASPECT_COLOR_BIT,
range,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
endSingleTimeCommands(commandBuffer); endSingleTimeCommands(commandBuffer);