From 9fe2815ab4523694425cbc3e3e949af982a43206 Mon Sep 17 00:00:00 2001 From: Anish Bhobe Date: Thu, 12 Jun 2025 23:37:07 +0200 Subject: [PATCH] Major Cleanup. --- AppState.cpp | 26 +- AppState.h | 28 +- Blaze.cpp | 268 ++++++++-------- Blaze.vcxproj | 1 - Blaze.vcxproj.filters | 3 - Frame.cpp | 78 ++--- Frame.h | 19 +- GlobalMemory.cpp | 80 ++--- GlobalMemory.h | 34 +- MacroUtils.h | 2 +- MathUtil.h | 8 +- MemoryUtils.h | 10 - MiscData.cpp | 500 ++++++++++++++--------------- MiscData.h | 16 +- RenderDevice.cpp | 713 ++++++++++++++++++++++-------------------- RenderDevice.h | 96 +++--- VmaImpl.cpp | 2 +- 17 files changed, 956 insertions(+), 928 deletions(-) delete mode 100644 MemoryUtils.h diff --git a/AppState.cpp b/AppState.cpp index 49daffe..448e0ae 100644 --- a/AppState.cpp +++ b/AppState.cpp @@ -3,15 +3,15 @@ #include #include "GlobalMemory.h" -#include "RenderDevice.h" #include "MiscData.h" +#include "RenderDevice.h" bool AppState::isInit() const { return window and renderDevice and renderDevice->isInit(); } -void AppState::cleanup() +void AppState::destroy() { if (!isInit()) return; @@ -19,26 +19,30 @@ void AppState::cleanup() Take(miscData)->cleanup(*renderDevice); - Take(renderDevice)->cleanup(); + Take(renderDevice)->destroy(); SDL_DestroyWindow(Take(window)); } -AppState::AppState(SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData): window{ window } +AppState::AppState(SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData) + : window{ window } , renderDevice{ renderDevice } - , miscData{ miscData } -{ + , miscData{ miscData } { } AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t const height) { - SDL_Window* window = SDL_CreateWindow("Blaze Test", static_cast(width), static_cast(height), SDL_WINDOW_VULKAN); + SDL_Window* window = SDL_CreateWindow( + "Blaze Test", + static_cast(width), + static_cast(height), + SDL_WINDOW_VULKAN); if (!window) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s", SDL_GetError()); return nullptr; } - auto state = memory->getState(); + auto state = memory->getState(); RenderDevice* renderDevice = CreateRenderDevice(memory, { .window = window }); if (!renderDevice->isInit()) { @@ -49,16 +53,16 @@ AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t co auto* miscDataAllocation = memory->allocate(sizeof(MiscData)); - MiscData* miscData = new (miscDataAllocation) MiscData{}; + MiscData* miscData = new(miscDataAllocation) MiscData{}; miscData->init(*renderDevice); auto* allocation = memory->allocate(sizeof(AppState)); - AppState* appState = new (allocation) AppState{ window, renderDevice, miscData }; + AppState* appState = new(allocation) AppState{ window, renderDevice, miscData }; return appState; } AppState::~AppState() { - cleanup(); + ASSERT(!isInit()); } diff --git a/AppState.h b/AppState.h index e693a78..48e0b82 100644 --- a/AppState.h +++ b/AppState.h @@ -2,29 +2,31 @@ #include -struct GlobalMemory; struct SDL_Window; + +struct GlobalMemory; struct RenderDevice; struct MiscData; struct AppState { - SDL_Window* window; - RenderDevice* renderDevice; - MiscData* miscData; + SDL_Window* window; + RenderDevice* renderDevice; + MiscData* miscData; - [[nodiscard]] bool isInit() const; - void cleanup(); + [[nodiscard]] + bool isInit() const; + void destroy(); - AppState(SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData); + AppState( SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData ); - AppState(AppState const& other) = delete; - AppState(AppState&& other) noexcept = delete; + AppState( AppState const& other ) = delete; + AppState( AppState&& other ) noexcept = delete; - AppState& operator=(AppState const& other) = delete; - AppState& operator=(AppState&& other) noexcept = delete; + AppState& operator=( AppState const& other ) = delete; + AppState& operator=( AppState&& other ) noexcept = delete; - ~AppState(); + ~AppState(); }; -AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t const height); +AppState* CreateAppState( GlobalMemory* memory, uint32_t const width, uint32_t const height ); diff --git a/Blaze.cpp b/Blaze.cpp index f6f0b82..43be370 100644 --- a/Blaze.cpp +++ b/Blaze.cpp @@ -23,187 +23,189 @@ #include "RenderDevice.h" #include "MiscData.h" -constexpr uint32_t WIDTH = 1280; -constexpr uint32_t HEIGHT = 720; +constexpr uint32_t WIDTH = 1280; +constexpr uint32_t HEIGHT = 720; constexpr uint32_t NUM_FRAMES = 3; using Byte = uint8_t; -constexpr size_t operator ""_KiB(size_t const value) +constexpr size_t operator ""_KiB( size_t const value ) { - return value * 1024; + return value * 1024; } -constexpr size_t operator ""_MiB(size_t const value) +constexpr size_t operator ""_MiB( size_t const value ) { - return value * 1024_KiB; + return value * 1024_KiB; } -constexpr size_t operator ""_GiB(size_t const value) +constexpr size_t operator ""_GiB( size_t const value ) { - return value * 1024_MiB; + return value * 1024_MiB; } namespace Blaze::Global { - GlobalMemory g_Memory; +GlobalMemory g_Memory; } -SDL_AppResult SDL_AppInit(void** pAppState, int, char**) +SDL_AppResult SDL_AppInit( void** pAppState, int, char** ) { - SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS); + SDL_Init( SDL_INIT_VIDEO | SDL_INIT_EVENTS ); - Blaze::Global::g_Memory.init(128_MiB); + Blaze::Global::g_Memory.init( 128_MiB ); - *pAppState = CreateAppState(&Blaze::Global::g_Memory, WIDTH, HEIGHT); - if (!*pAppState) - return SDL_APP_FAILURE; + *pAppState = CreateAppState( &Blaze::Global::g_Memory, WIDTH, HEIGHT ); + if ( !*pAppState ) return SDL_APP_FAILURE; - AppState& appState = *static_cast(*pAppState); + AppState& appState = *static_cast(*pAppState); - if (!appState.isInit()) - { - return SDL_APP_FAILURE; - } + if ( !appState.isInit() ) + { + return SDL_APP_FAILURE; + } - return SDL_APP_CONTINUE; + return SDL_APP_CONTINUE; } -SDL_AppResult SDL_AppIterate(void* appstate) +SDL_AppResult SDL_AppIterate( void* appstate ) { - AppState& appState = *static_cast(appstate); - RenderDevice& renderDevice = *appState.renderDevice; - MiscData& misc = *appState.miscData; - Frame& currentFrame = renderDevice.frames[renderDevice.frameIndex]; + AppState& appState = *static_cast(appstate); + RenderDevice& renderDevice = *appState.renderDevice; + MiscData& misc = *appState.miscData; + Frame& currentFrame = renderDevice.frames[renderDevice.frameIndex]; - VK_CHECK(vkWaitForFences(renderDevice.device, 1, ¤tFrame.frameReadyToReuse, VK_TRUE, std::numeric_limits::max())); - // All resources of frame 'frameIndex' are free. + VK_CHECK( + vkWaitForFences(renderDevice.device, 1, ¤tFrame.frameReadyToReuse, VK_TRUE, std::numeric_limits::max + ()) ); + // All resources of frame 'frameIndex' are free. - uint32_t currentImageIndex; - VK_CHECK(vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits::max(), currentFrame.imageAcquiredSemaphore, nullptr, ¤tImageIndex)); + uint32_t currentImageIndex; + VK_CHECK( + vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits::max(), + currentFrame.imageAcquiredSemaphore, nullptr, ¤tImageIndex) ); - VK_CHECK(vkResetFences(renderDevice.device, 1, ¤tFrame.frameReadyToReuse)); - VK_CHECK(vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0)); + VK_CHECK( vkResetFences(renderDevice.device, 1, ¤tFrame.frameReadyToReuse) ); + VK_CHECK( vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0) ); - misc.acquireToRenderBarrier.image = renderDevice.swapchainImages[currentImageIndex]; - misc.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex]; + misc.acquireToRenderBarrier.image = renderDevice.swapchainImages[currentImageIndex]; + misc.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex]; - VkCommandBuffer cmd = currentFrame.commandBuffer; + VkCommandBuffer cmd = currentFrame.commandBuffer; - VkCommandBufferBeginInfo constexpr beginInfo = { - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - .pNext = nullptr, - .flags = 0, - .pInheritanceInfo = nullptr, - }; + VkCommandBufferBeginInfo constexpr beginInfo = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + .pNext = nullptr, + .flags = 0, + .pInheritanceInfo = nullptr, + }; - VkClearColorValue constexpr static BLACK_CLEAR = { - .float32 = { 0.0f, 0.0f, 0.0f, 1.0f }, - }; + VkClearColorValue constexpr static BLACK_CLEAR = { + .float32 = { 0.0f, 0.0f, 0.0f, 1.0f }, + }; - VK_CHECK(vkBeginCommandBuffer(cmd, &beginInfo)); - { - VkRenderingAttachmentInfo const attachmentInfo = { - .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, - .pNext = nullptr, - .imageView = renderDevice.swapchainViews[currentImageIndex], - .imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - .resolveMode = VK_RESOLVE_MODE_NONE, - .resolveImageView = nullptr, - .resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED, - .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR, - .storeOp = VK_ATTACHMENT_STORE_OP_STORE, - .clearValue = {.color = BLACK_CLEAR}, - }; + VK_CHECK( vkBeginCommandBuffer(cmd, &beginInfo) ); + { + VkRenderingAttachmentInfo const attachmentInfo = { + .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, + .pNext = nullptr, + .imageView = renderDevice.swapchainViews[currentImageIndex], + .imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .resolveMode = VK_RESOLVE_MODE_NONE, + .resolveImageView = nullptr, + .resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .clearValue = { .color = BLACK_CLEAR }, + }; - VkRenderingInfo renderingInfo = { - .sType = VK_STRUCTURE_TYPE_RENDERING_INFO, - .pNext = nullptr, - .flags = 0, - .renderArea = {.offset = {0,0}, .extent = renderDevice.swapchainExtent}, - .layerCount = 1, - .viewMask = 0, - .colorAttachmentCount = 1, - .pColorAttachments = &attachmentInfo, - .pDepthAttachment = nullptr, - .pStencilAttachment = nullptr, - }; + VkRenderingInfo renderingInfo = { + .sType = VK_STRUCTURE_TYPE_RENDERING_INFO, + .pNext = nullptr, + .flags = 0, + .renderArea = { .offset = { 0, 0 }, .extent = renderDevice.swapchainExtent }, + .layerCount = 1, + .viewMask = 0, + .colorAttachmentCount = 1, + .pColorAttachments = &attachmentInfo, + .pDepthAttachment = nullptr, + .pStencilAttachment = nullptr, + }; - vkCmdPipelineBarrier2(cmd, &misc.acquireToRenderDependency); - vkCmdBeginRendering(cmd, &renderingInfo); - { - VkViewport viewport = { - .x = 0, - .y = static_cast(renderDevice.swapchainExtent.height), - .width = static_cast(renderDevice.swapchainExtent.width), - .height = -static_cast(renderDevice.swapchainExtent.height), - .minDepth = 0.0f, - .maxDepth = 1.0f, - }; - vkCmdSetViewport(cmd, 0, 1, &viewport); - VkRect2D scissor = { - .offset = {0, 0}, - .extent = renderDevice.swapchainExtent, - }; - vkCmdSetScissor(cmd, 0, 1, &scissor); + vkCmdPipelineBarrier2( cmd, &misc.acquireToRenderDependency ); + vkCmdBeginRendering( cmd, &renderingInfo ); + { + VkViewport viewport = { + .x = 0, + .y = static_cast(renderDevice.swapchainExtent.height), + .width = static_cast(renderDevice.swapchainExtent.width), + .height = -static_cast(renderDevice.swapchainExtent.height), + .minDepth = 0.0f, + .maxDepth = 1.0f, + }; + vkCmdSetViewport( cmd, 0, 1, &viewport ); + VkRect2D scissor = { + .offset = { 0, 0 }, + .extent = renderDevice.swapchainExtent, + }; + vkCmdSetScissor( cmd, 0, 1, &scissor ); - // Render Something? - vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline); - vkCmdDraw(cmd, 3, 1, 0, 0); + // Render Something? + vkCmdBindPipeline( cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline ); + vkCmdDraw( cmd, 3, 1, 0, 0 ); + } + vkCmdEndRendering( cmd ); + vkCmdPipelineBarrier2( cmd, &misc.renderToPresentDependency ); + } + VK_CHECK( vkEndCommandBuffer(cmd) ); - } - vkCmdEndRendering(cmd); - vkCmdPipelineBarrier2(cmd, &misc.renderToPresentDependency); - } - VK_CHECK(vkEndCommandBuffer(cmd)); + VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + VkSubmitInfo const submitInfo = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .pNext = nullptr, + .waitSemaphoreCount = 1, + .pWaitSemaphores = ¤tFrame.imageAcquiredSemaphore, + .pWaitDstStageMask = &stageMask, + .commandBufferCount = 1, + .pCommandBuffers = &cmd, + .signalSemaphoreCount = 1, + .pSignalSemaphores = ¤tFrame.renderFinishedSemaphore, + }; + VK_CHECK( vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse) ); - VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - VkSubmitInfo const submitInfo = { - .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, - .pNext = nullptr, - .waitSemaphoreCount = 1, - .pWaitSemaphores = ¤tFrame.imageAcquiredSemaphore, - .pWaitDstStageMask = &stageMask, - .commandBufferCount = 1, - .pCommandBuffers = &cmd, - .signalSemaphoreCount = 1, - .pSignalSemaphores = ¤tFrame.renderFinishedSemaphore, - }; - VK_CHECK(vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse)); + VkPresentInfoKHR const presentInfo = { + .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + .pNext = nullptr, + .waitSemaphoreCount = 1, + .pWaitSemaphores = ¤tFrame.renderFinishedSemaphore, + .swapchainCount = 1, + .pSwapchains = &renderDevice.swapchain, + .pImageIndices = ¤tImageIndex, + .pResults = nullptr, + }; - VkPresentInfoKHR const presentInfo = { - .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, - .pNext = nullptr, - .waitSemaphoreCount = 1, - .pWaitSemaphores = ¤tFrame.renderFinishedSemaphore, - .swapchainCount = 1, - .pSwapchains = &renderDevice.swapchain, - .pImageIndices = ¤tImageIndex, - .pResults = nullptr, - }; + VK_CHECK( vkQueuePresentKHR(renderDevice.directQueue, &presentInfo) ); - VK_CHECK(vkQueuePresentKHR(renderDevice.directQueue, &presentInfo)); + renderDevice.frameIndex = (renderDevice.frameIndex + 1) % NUM_FRAMES; - renderDevice.frameIndex = (renderDevice.frameIndex + 1) % NUM_FRAMES; - - return SDL_APP_CONTINUE; + return SDL_APP_CONTINUE; } -SDL_AppResult SDL_AppEvent(void*, SDL_Event* event) +SDL_AppResult SDL_AppEvent( void*, SDL_Event* event ) { - if (event->type == SDL_EVENT_QUIT) - { - return SDL_APP_SUCCESS; - } + if ( event->type == SDL_EVENT_QUIT ) + { + return SDL_APP_SUCCESS; + } - return SDL_APP_CONTINUE; + return SDL_APP_CONTINUE; } -void SDL_AppQuit(void* appstate, SDL_AppResult) +void SDL_AppQuit( void* appstate, SDL_AppResult ) { - AppState* appState = static_cast (appstate); + AppState* appState = static_cast(appstate); - appState->cleanup(); + appState->destroy(); - Blaze::Global::g_Memory.destroy(); -} \ No newline at end of file + Blaze::Global::g_Memory.destroy(); +} diff --git a/Blaze.vcxproj b/Blaze.vcxproj index f13e2be..a403489 100644 --- a/Blaze.vcxproj +++ b/Blaze.vcxproj @@ -183,7 +183,6 @@ - diff --git a/Blaze.vcxproj.filters b/Blaze.vcxproj.filters index 5ffccc0..5559e39 100644 --- a/Blaze.vcxproj.filters +++ b/Blaze.vcxproj.filters @@ -75,9 +75,6 @@ Header Files - - Header Files - Header Files diff --git a/Frame.cpp b/Frame.cpp index 372289a..4f60a6f 100644 --- a/Frame.cpp +++ b/Frame.cpp @@ -7,58 +7,58 @@ bool Frame::isInit() const { - return static_cast(commandPool); + return static_cast(commandPool); } -Frame::Frame(VkDevice const device, uint32_t const directQueueFamilyIndex) +Frame::Frame( VkDevice const device, uint32_t const directQueueFamilyIndex ) { - VkCommandPoolCreateInfo const commandPoolCreateInfo = { - .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - .pNext = nullptr, - .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, - .queueFamilyIndex = directQueueFamilyIndex, - }; - VK_CHECK(vkCreateCommandPool(device, &commandPoolCreateInfo, nullptr, &commandPool)); + VkCommandPoolCreateInfo const commandPoolCreateInfo = { + .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + .pNext = nullptr, + .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, + .queueFamilyIndex = directQueueFamilyIndex, + }; + VK_CHECK( vkCreateCommandPool(device, &commandPoolCreateInfo, nullptr, &commandPool) ); - VkCommandBufferAllocateInfo const commandBufferAllocateInfo = { - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - .pNext = nullptr, - .commandPool = commandPool, - .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, - .commandBufferCount = 1, - }; - VK_CHECK(vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer)); + VkCommandBufferAllocateInfo const commandBufferAllocateInfo = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .pNext = nullptr, + .commandPool = commandPool, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandBufferCount = 1, + }; + VK_CHECK( vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer) ); - VkSemaphoreCreateInfo constexpr semaphoreCreateInfo = { - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, - .pNext = nullptr, - .flags = 0 - }; - VK_CHECK(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &imageAcquiredSemaphore)); - VK_CHECK(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &renderFinishedSemaphore)); + VkSemaphoreCreateInfo constexpr semaphoreCreateInfo = { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + .pNext = nullptr, + .flags = 0 + }; + VK_CHECK( vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &imageAcquiredSemaphore) ); + VK_CHECK( vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &renderFinishedSemaphore) ); - VkFenceCreateInfo constexpr fenceCreateInfo = { - .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, - .pNext = nullptr, - .flags = VK_FENCE_CREATE_SIGNALED_BIT, - }; - VK_CHECK(vkCreateFence(device, &fenceCreateInfo, nullptr, &frameReadyToReuse)); + VkFenceCreateInfo constexpr fenceCreateInfo = { + .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + .pNext = nullptr, + .flags = VK_FENCE_CREATE_SIGNALED_BIT, + }; + VK_CHECK( vkCreateFence(device, &fenceCreateInfo, nullptr, &frameReadyToReuse) ); } -void Frame::cleanup(RenderDevice const& renderDevice) +void Frame::destroy( RenderDevice const& renderDevice ) { - if (!isInit()) return; + if ( !isInit() ) return; - VkDevice const device = renderDevice.device; + VkDevice const device = renderDevice.device; - vkDestroyCommandPool(device, Take(commandPool), nullptr); - vkDestroyFence(device, Take(frameReadyToReuse), nullptr); - vkDestroySemaphore(device, Take(imageAcquiredSemaphore), nullptr); - vkDestroySemaphore(device, Take(renderFinishedSemaphore), nullptr); + vkDestroyCommandPool( device, Take( commandPool ), nullptr ); + vkDestroyFence( device, Take( frameReadyToReuse ), nullptr ); + vkDestroySemaphore( device, Take( imageAcquiredSemaphore ), nullptr ); + vkDestroySemaphore( device, Take( renderFinishedSemaphore ), nullptr ); } Frame::~Frame() { - // Manual Cleanup Required. - ASSERT(not isInit()); + // Manual Cleanup Required. + ASSERT( not isInit() ); } diff --git a/Frame.h b/Frame.h index 99d26f9..7933011 100644 --- a/Frame.h +++ b/Frame.h @@ -7,18 +7,17 @@ struct RenderDevice; struct Frame { - VkCommandPool commandPool; - VkCommandBuffer commandBuffer; - VkSemaphore imageAcquiredSemaphore; - VkSemaphore renderFinishedSemaphore; - VkFence frameReadyToReuse; + VkCommandPool commandPool; + VkCommandBuffer commandBuffer; + VkSemaphore imageAcquiredSemaphore; + VkSemaphore renderFinishedSemaphore; + VkFence frameReadyToReuse; - [[nodiscard]] bool isInit() const; + [[nodiscard]] bool isInit() const; - Frame(VkDevice device, uint32_t directQueueFamilyIndex); + Frame( VkDevice device, uint32_t directQueueFamilyIndex ); - void cleanup(RenderDevice const& renderDevice); + void destroy( RenderDevice const& renderDevice ); - ~Frame(); + ~Frame(); }; - diff --git a/GlobalMemory.cpp b/GlobalMemory.cpp index dec7719..63ff28f 100644 --- a/GlobalMemory.cpp +++ b/GlobalMemory.cpp @@ -2,64 +2,70 @@ #include -void GlobalMemory::init(size_t const size) +void GlobalMemory::init( size_t const size ) { - memory = new Byte[size]; - capacity = size; - available = size; + memory = new Byte[size]; + capacity = size; + available = size; } void GlobalMemory::destroy() { - Byte const* originalMemory = memory - (capacity - available); - delete[] originalMemory; - memory = nullptr; - available = 0; - capacity = 0; + Byte const* originalMemory = memory - (capacity - available); + delete[] originalMemory; + memory = nullptr; + available = 0; + capacity = 0; } -Byte* GlobalMemory::allocate(size_t const size) +Byte* GlobalMemory::allocate( size_t const size ) { - assert(size <= available && "No enough space available"); + assert( size <= available && "No enough space available" ); - Byte* retVal = memory; - memory += size; - available -= size; - SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "ALLOC: %p -> %p (%llu) (avail: %llu)", reinterpret_cast(retVal), reinterpret_cast(memory), size, available); + Byte* retVal = memory; + memory += size; + available -= size; + SDL_LogInfo( + SDL_LOG_CATEGORY_SYSTEM, + "ALLOC: %p -> %p (%llu) (avail: %llu)", + reinterpret_cast(retVal), + reinterpret_cast(memory), + size, + available ); - return retVal; + return retVal; } -Byte* GlobalMemory::allocate(size_t const size, size_t const alignment) +Byte* GlobalMemory::allocate( size_t const size, size_t const alignment ) { - uintptr_t const addr = reinterpret_cast(memory); - uintptr_t const foundOffset = addr % alignment; + uintptr_t const addr = reinterpret_cast(memory); + uintptr_t const foundOffset = addr % alignment; - if (foundOffset == 0) - { - return allocate(size); - } + if ( foundOffset == 0 ) + { + return allocate( size ); + } - uintptr_t const offset = alignment - foundOffset; - size_t const allocationSize = size + offset; + uintptr_t const offset = alignment - foundOffset; + size_t const allocationSize = size + offset; - return offset + allocate(allocationSize); + return offset + allocate( allocationSize ); } GlobalMemory::State GlobalMemory::getState() const { - SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "TEMP: %p %llu", reinterpret_cast(memory), available); - return { - .memory = memory, - .available = available, - }; + SDL_LogInfo( SDL_LOG_CATEGORY_SYSTEM, "TEMP: %p %llu", reinterpret_cast(memory), available ); + return { + .memory = memory, + .available = available, + }; } -void GlobalMemory::restoreState(State const& state) +void GlobalMemory::restoreState( State const& state ) { - assert(memory >= state.memory); //< Behind top of allocator - assert(memory - (capacity - available) <= state.memory); //< Ahead of start of allocator - SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "RESTORE: %p %llu", reinterpret_cast(memory), available); - memory = state.memory; - available = state.available; + ASSERT( memory >= state.memory ); //< Behind top of allocator + ASSERT( memory - (capacity - available) <= state.memory ); //< Ahead of start of allocator + SDL_LogInfo( SDL_LOG_CATEGORY_SYSTEM, "RESTORE: %p %llu", reinterpret_cast(memory), available ); + memory = state.memory; + available = state.available; } diff --git a/GlobalMemory.h b/GlobalMemory.h index 29e30e2..c875ddb 100644 --- a/GlobalMemory.h +++ b/GlobalMemory.h @@ -8,27 +8,27 @@ using Byte = uint8_t; struct GlobalMemory { - struct State - { - Byte* memory; - size_t available; - }; + struct State + { + Byte* memory; + size_t available; + }; - Byte* memory; - size_t available; - size_t capacity; + Byte* memory; + size_t available; + size_t capacity; - void init(size_t const size); + void init( size_t size ); - void destroy(); + void destroy(); - Byte* allocate(size_t const size); + Byte* allocate( size_t size ); - Byte* allocate(size_t const size, size_t const alignment); + Byte* allocate( size_t size, size_t alignment ); - // Do not do any permanent allocations after calling this. - [[nodiscard]] State getState() const; + // Do not do any permanent allocations after calling this. + [[nodiscard]] State getState() const; - // Call this before permanent allocations. - void restoreState(State const& state); -}; \ No newline at end of file + // Call this before permanent allocations. + void restoreState( State const& state ); +}; diff --git a/MacroUtils.h b/MacroUtils.h index d4ddca9..ce32a14 100644 --- a/MacroUtils.h +++ b/MacroUtils.h @@ -26,4 +26,4 @@ do { \ } \ } while(false) -#define Take(OBJ) std::exchange(OBJ, {}) \ No newline at end of file +#define Take(OBJ) std::exchange(OBJ, {}) diff --git a/MathUtil.h b/MathUtil.h index 211b9b3..7f7177d 100644 --- a/MathUtil.h +++ b/MathUtil.h @@ -2,8 +2,8 @@ #include -template -T Clamp(T const val, T const minVal, T const maxVal) +template < std::totally_ordered T > +T Clamp( T const val, T const minVal, T const maxVal ) { - return std::min(maxVal, std::max(val, minVal)); -} \ No newline at end of file + return std::min( maxVal, std::max( val, minVal ) ); +} diff --git a/MemoryUtils.h b/MemoryUtils.h deleted file mode 100644 index 3059f97..0000000 --- a/MemoryUtils.h +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include -#include -#include - -using global_allocator_t = foonathan::memory::memory_stack; - -using subsystem_allocator_t = foonathan::memory::memory_stack>; -using temporary_allocator_t = foonathan::memory::temporary_allocator; \ No newline at end of file diff --git a/MiscData.cpp b/MiscData.cpp index 11fd91d..bbc3f8d 100644 --- a/MiscData.cpp +++ b/MiscData.cpp @@ -7,283 +7,283 @@ #include "RenderDevice.h" -void MiscData::init(RenderDevice const& renderDevice) +void MiscData::init( RenderDevice const& renderDevice ) { - VkDevice const device = renderDevice.device; - { - size_t dataSize; - void* rawData = SDL_LoadFile("Triangle.spv", &dataSize); - ASSERT(dataSize % 4 == 0); + VkDevice const device = renderDevice.device; + { + size_t dataSize; + void* rawData = SDL_LoadFile( "Triangle.spv", &dataSize ); + ASSERT( dataSize % 4 == 0 ); - if (not rawData) - { - SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError()); - abort(); - } + if ( !rawData ) + { + SDL_LogError( SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError() ); + abort(); + } - auto data = static_cast(rawData); + auto data = static_cast(rawData); - VkShaderModuleCreateInfo const shaderModuleCreateInfo = { - .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .codeSize = dataSize, - .pCode = data, - }; + VkShaderModuleCreateInfo const shaderModuleCreateInfo = { + .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .codeSize = dataSize, + .pCode = data, + }; - VkShaderModule shaderModule; - VK_CHECK(vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule)); + VkShaderModule shaderModule; + VK_CHECK( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule) ); - VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .setLayoutCount = 0, - .pSetLayouts = nullptr, - .pushConstantRangeCount = 0, - .pPushConstantRanges = nullptr, - }; - VK_CHECK(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout)); + VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .setLayoutCount = 0, + .pSetLayouts = nullptr, + .pushConstantRangeCount = 0, + .pPushConstantRanges = nullptr, + }; + VK_CHECK( vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) ); - std::array stages = { - VkPipelineShaderStageCreateInfo{ - .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .stage = VK_SHADER_STAGE_VERTEX_BIT, - .module = shaderModule, - .pName = "VertexMain", - .pSpecializationInfo = nullptr, - }, - VkPipelineShaderStageCreateInfo{ - .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .stage = VK_SHADER_STAGE_FRAGMENT_BIT, - .module = shaderModule, - .pName = "FragmentMain", - .pSpecializationInfo = nullptr, - } - }; + std::array stages = { + VkPipelineShaderStageCreateInfo{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stage = VK_SHADER_STAGE_VERTEX_BIT, + .module = shaderModule, + .pName = "VertexMain", + .pSpecializationInfo = nullptr, + }, + VkPipelineShaderStageCreateInfo{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stage = VK_SHADER_STAGE_FRAGMENT_BIT, + .module = shaderModule, + .pName = "FragmentMain", + .pSpecializationInfo = nullptr, + } + }; - VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .vertexBindingDescriptionCount = 0, - .pVertexBindingDescriptions = nullptr, - .vertexAttributeDescriptionCount = 0, - .pVertexAttributeDescriptions = nullptr, - }; + VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .vertexBindingDescriptionCount = 0, + .pVertexBindingDescriptions = nullptr, + .vertexAttributeDescriptionCount = 0, + .pVertexAttributeDescriptions = nullptr, + }; - VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - .primitiveRestartEnable = VK_FALSE, - }; + VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + .primitiveRestartEnable = VK_FALSE, + }; - VkPipelineTessellationStateCreateInfo constexpr tessellationState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .patchControlPoints = 0, - }; + VkPipelineTessellationStateCreateInfo constexpr tessellationState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .patchControlPoints = 0, + }; - VkPipelineViewportStateCreateInfo constexpr viewportState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .viewportCount = 1, - .pViewports = nullptr, - .scissorCount = 1, - .pScissors = nullptr, - }; + VkPipelineViewportStateCreateInfo constexpr viewportState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .viewportCount = 1, + .pViewports = nullptr, + .scissorCount = 1, + .pScissors = nullptr, + }; - VkPipelineRasterizationStateCreateInfo constexpr rasterizationState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .depthClampEnable = VK_TRUE, - .rasterizerDiscardEnable = VK_FALSE, - .polygonMode = VK_POLYGON_MODE_FILL, - .cullMode = VK_CULL_MODE_NONE, - .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, - .depthBiasEnable = VK_FALSE, - .depthBiasConstantFactor = 0.0f, - .depthBiasClamp = 0.0f, - .depthBiasSlopeFactor = 0.0f, - .lineWidth = 1.0f, - }; + VkPipelineRasterizationStateCreateInfo constexpr rasterizationState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .depthClampEnable = VK_TRUE, + .rasterizerDiscardEnable = VK_FALSE, + .polygonMode = VK_POLYGON_MODE_FILL, + .cullMode = VK_CULL_MODE_NONE, + .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, + .depthBiasEnable = VK_FALSE, + .depthBiasConstantFactor = 0.0f, + .depthBiasClamp = 0.0f, + .depthBiasSlopeFactor = 0.0f, + .lineWidth = 1.0f, + }; - VkPipelineMultisampleStateCreateInfo constexpr multisampleState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, - .sampleShadingEnable = VK_FALSE, - .minSampleShading = 0.0f, - .pSampleMask = nullptr, - .alphaToCoverageEnable = VK_FALSE, - .alphaToOneEnable = VK_FALSE, - }; + VkPipelineMultisampleStateCreateInfo constexpr multisampleState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, + .sampleShadingEnable = VK_FALSE, + .minSampleShading = 0.0f, + .pSampleMask = nullptr, + .alphaToCoverageEnable = VK_FALSE, + .alphaToOneEnable = VK_FALSE, + }; - VkPipelineDepthStencilStateCreateInfo constexpr depthStencilState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .depthTestEnable = VK_FALSE, - .depthWriteEnable = VK_FALSE, - .depthCompareOp = VK_COMPARE_OP_ALWAYS, - .depthBoundsTestEnable = VK_FALSE, - .stencilTestEnable = VK_FALSE, - .front = {}, - .back = {}, - .minDepthBounds = 0.0f, - .maxDepthBounds = 1.0f, - }; + VkPipelineDepthStencilStateCreateInfo constexpr depthStencilState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .depthTestEnable = VK_FALSE, + .depthWriteEnable = VK_FALSE, + .depthCompareOp = VK_COMPARE_OP_ALWAYS, + .depthBoundsTestEnable = VK_FALSE, + .stencilTestEnable = VK_FALSE, + .front = {}, + .back = {}, + .minDepthBounds = 0.0f, + .maxDepthBounds = 1.0f, + }; - VkPipelineColorBlendAttachmentState constexpr colorBlendAttachmentState = { - .blendEnable = VK_FALSE, - .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, - .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .colorBlendOp = VK_BLEND_OP_ADD, - .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, - .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, - .alphaBlendOp = VK_BLEND_OP_ADD, - .colorWriteMask = VK_COLOR_COMPONENT_R_BIT - | VK_COLOR_COMPONENT_G_BIT - | VK_COLOR_COMPONENT_B_BIT - | VK_COLOR_COMPONENT_A_BIT, - }; + VkPipelineColorBlendAttachmentState constexpr colorBlendAttachmentState = { + .blendEnable = VK_FALSE, + .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, + .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .colorBlendOp = VK_BLEND_OP_ADD, + .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, + .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, + .alphaBlendOp = VK_BLEND_OP_ADD, + .colorWriteMask = VK_COLOR_COMPONENT_R_BIT + | VK_COLOR_COMPONENT_G_BIT + | VK_COLOR_COMPONENT_B_BIT + | VK_COLOR_COMPONENT_A_BIT, + }; - VkPipelineColorBlendStateCreateInfo const colorBlendState = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .logicOpEnable = VK_FALSE, - .logicOp = VK_LOGIC_OP_COPY, - .attachmentCount = 1, - .pAttachments = &colorBlendAttachmentState, - .blendConstants = {0.0f, 0.0f, 0.0f, 0.0f}, - }; + VkPipelineColorBlendStateCreateInfo const colorBlendState = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .logicOpEnable = VK_FALSE, + .logicOp = VK_LOGIC_OP_COPY, + .attachmentCount = 1, + .pAttachments = &colorBlendAttachmentState, + .blendConstants = { 0.0f, 0.0f, 0.0f, 0.0f }, + }; - std::array constexpr dynamicStates = { - VK_DYNAMIC_STATE_VIEWPORT, - VK_DYNAMIC_STATE_SCISSOR - }; + std::array constexpr dynamicStates = { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR + }; - VkPipelineDynamicStateCreateInfo const dynamicStateCreateInfo = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .dynamicStateCount = static_cast(dynamicStates.size()), - .pDynamicStates = dynamicStates.data() - }; + VkPipelineDynamicStateCreateInfo const dynamicStateCreateInfo = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .dynamicStateCount = static_cast(dynamicStates.size()), + .pDynamicStates = dynamicStates.data() + }; - VkPipelineRenderingCreateInfoKHR const renderingCreateInfo = { - .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, - .colorAttachmentCount = 1, - .pColorAttachmentFormats = &renderDevice.swapchainFormat, - }; + VkPipelineRenderingCreateInfoKHR const renderingCreateInfo = { + .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, + .colorAttachmentCount = 1, + .pColorAttachmentFormats = &renderDevice.swapchainFormat, + }; - VkGraphicsPipelineCreateInfo const graphicsPipelineCreateInfo = { - .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - .pNext = &renderingCreateInfo, - .flags = 0, - .stageCount = static_cast(stages.size()), - .pStages = stages.data(), - .pVertexInputState = &vertexInputState, - .pInputAssemblyState = &inputAssembly, - .pTessellationState = &tessellationState, - .pViewportState = &viewportState, - .pRasterizationState = &rasterizationState, - .pMultisampleState = &multisampleState, - .pDepthStencilState = &depthStencilState, - .pColorBlendState = &colorBlendState, - .pDynamicState = &dynamicStateCreateInfo, - .layout = pipelineLayout, - .renderPass = nullptr, - .subpass = 0, - .basePipelineHandle = nullptr, - .basePipelineIndex = 0, - }; + VkGraphicsPipelineCreateInfo const graphicsPipelineCreateInfo = { + .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + .pNext = &renderingCreateInfo, + .flags = 0, + .stageCount = static_cast(stages.size()), + .pStages = stages.data(), + .pVertexInputState = &vertexInputState, + .pInputAssemblyState = &inputAssembly, + .pTessellationState = &tessellationState, + .pViewportState = &viewportState, + .pRasterizationState = &rasterizationState, + .pMultisampleState = &multisampleState, + .pDepthStencilState = &depthStencilState, + .pColorBlendState = &colorBlendState, + .pDynamicState = &dynamicStateCreateInfo, + .layout = pipelineLayout, + .renderPass = nullptr, + .subpass = 0, + .basePipelineHandle = nullptr, + .basePipelineIndex = 0, + }; - VK_CHECK(vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &trianglePipeline)); + VK_CHECK( vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &trianglePipeline) ); - vkDestroyShaderModule(device, shaderModule, nullptr); + vkDestroyShaderModule( device, shaderModule, nullptr ); - SDL_free(rawData); - } + SDL_free( rawData ); + } - acquireToRenderBarrier = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, - .pNext = nullptr, - .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, - .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, - .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, - .dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, - .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, - .newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .subresourceRange = { - .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, - .baseMipLevel = 0, - .levelCount = 1, - .baseArrayLayer = 0, - .layerCount = 1, - } - }; - acquireToRenderDependency = { - .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, - .pNext = nullptr, - .dependencyFlags = 0, - .memoryBarrierCount = 0, - .pMemoryBarriers = nullptr, - .bufferMemoryBarrierCount = 0, - .pBufferMemoryBarriers = nullptr, - .imageMemoryBarrierCount = 1, - .pImageMemoryBarriers = &acquireToRenderBarrier, - }; + acquireToRenderBarrier = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + .pNext = nullptr, + .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, + .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, + .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, + .dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, + .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + } + }; + acquireToRenderDependency = { + .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + .pNext = nullptr, + .dependencyFlags = 0, + .memoryBarrierCount = 0, + .pMemoryBarriers = nullptr, + .bufferMemoryBarrierCount = 0, + .pBufferMemoryBarriers = nullptr, + .imageMemoryBarrierCount = 1, + .pImageMemoryBarriers = &acquireToRenderBarrier, + }; - renderToPresentBarrier = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, - .pNext = nullptr, - .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, - .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, - .dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, - .dstAccessMask = VK_ACCESS_2_NONE, - .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, - .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .subresourceRange = { - .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, - .baseMipLevel = 0, - .levelCount = 1, - .baseArrayLayer = 0, - .layerCount = 1, - } - }; - renderToPresentDependency = { - .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, - .pNext = nullptr, - .dependencyFlags = 0, - .memoryBarrierCount = 0, - .pMemoryBarriers = nullptr, - .bufferMemoryBarrierCount = 0, - .pBufferMemoryBarriers = nullptr, - .imageMemoryBarrierCount = 1, - .pImageMemoryBarriers = &renderToPresentBarrier, - }; + renderToPresentBarrier = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + .pNext = nullptr, + .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, + .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, + .dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, + .dstAccessMask = VK_ACCESS_2_NONE, + .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + } + }; + renderToPresentDependency = { + .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + .pNext = nullptr, + .dependencyFlags = 0, + .memoryBarrierCount = 0, + .pMemoryBarriers = nullptr, + .bufferMemoryBarrierCount = 0, + .pBufferMemoryBarriers = nullptr, + .imageMemoryBarrierCount = 1, + .pImageMemoryBarriers = &renderToPresentBarrier, + }; } -void MiscData::cleanup(RenderDevice const& renderDevice) +void MiscData::cleanup( RenderDevice const& renderDevice ) { - VkDevice const device = renderDevice.device; + VkDevice const device = renderDevice.device; - vkDestroyPipeline(device, trianglePipeline, nullptr); - vkDestroyPipelineLayout(device, pipelineLayout, nullptr); + vkDestroyPipeline( device, trianglePipeline, nullptr ); + vkDestroyPipelineLayout( device, pipelineLayout, nullptr ); } diff --git a/MiscData.h b/MiscData.h index 092e9d0..0050012 100644 --- a/MiscData.h +++ b/MiscData.h @@ -6,14 +6,14 @@ struct RenderDevice; struct MiscData { - VkPipelineLayout pipelineLayout; - VkPipeline trianglePipeline; + VkPipelineLayout pipelineLayout; + VkPipeline trianglePipeline; - VkImageMemoryBarrier2 acquireToRenderBarrier; - VkDependencyInfo acquireToRenderDependency; - VkImageMemoryBarrier2 renderToPresentBarrier; - VkDependencyInfo renderToPresentDependency; + VkImageMemoryBarrier2 acquireToRenderBarrier; + VkDependencyInfo acquireToRenderDependency; + VkImageMemoryBarrier2 renderToPresentBarrier; + VkDependencyInfo renderToPresentDependency; - void init(RenderDevice const& renderDevice); - void cleanup(RenderDevice const& renderDevice); + void init( RenderDevice const& renderDevice ); + void cleanup( RenderDevice const& renderDevice ); }; diff --git a/RenderDevice.cpp b/RenderDevice.cpp index 583e35b..bce0078 100644 --- a/RenderDevice.cpp +++ b/RenderDevice.cpp @@ -14,426 +14,455 @@ RenderDevice::~RenderDevice() { - ASSERT(!isInit()); + ASSERT( !isInit() ); } // TODO: Failure Handling -RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo) +RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo ) { - ASSERT(createInfo.window); + ASSERT( createInfo.window ); - volkInitialize(); + volkInitialize(); - VkInstance instance; - // Create Instance - { - VkApplicationInfo constexpr applicationInfo = { - .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, - .pNext = nullptr, - .pApplicationName = "Test", - .applicationVersion = VK_MAKE_API_VERSION(0, 0, 1, 0), - .pEngineName = "Blaze", - .engineVersion = VK_MAKE_API_VERSION(0, 0, 1, 0), - .apiVersion = VK_API_VERSION_1_3, - }; + VkInstance instance; + // Create Instance + { + VkApplicationInfo constexpr applicationInfo = { + .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, + .pNext = nullptr, + .pApplicationName = "Test", + .applicationVersion = VK_MAKE_API_VERSION( 0, 0, 1, 0 ), + .pEngineName = "Blaze", + .engineVersion = VK_MAKE_API_VERSION( 0, 0, 1, 0 ), + .apiVersion = VK_API_VERSION_1_3, + }; - uint32_t instanceExtensionCount; - char const* const* instanceExtensions = SDL_Vulkan_GetInstanceExtensions(&instanceExtensionCount); + uint32_t instanceExtensionCount; + char const* const* instanceExtensions = SDL_Vulkan_GetInstanceExtensions( &instanceExtensionCount ); - VkInstanceCreateInfo const instanceCreateInfo = { - .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .pApplicationInfo = &applicationInfo, - .enabledLayerCount = 0, - .ppEnabledLayerNames = nullptr, - .enabledExtensionCount = instanceExtensionCount, - .ppEnabledExtensionNames = instanceExtensions, - }; + VkInstanceCreateInfo const instanceCreateInfo = { + .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .pApplicationInfo = &applicationInfo, + .enabledLayerCount = 0, + .ppEnabledLayerNames = nullptr, + .enabledExtensionCount = instanceExtensionCount, + .ppEnabledExtensionNames = instanceExtensions, + }; - VK_CHECK(vkCreateInstance(&instanceCreateInfo, nullptr, &instance)); - volkLoadInstance(instance); - } + VK_CHECK( vkCreateInstance(&instanceCreateInfo, nullptr, &instance) ); + volkLoadInstance( instance ); + } - VkSurfaceKHR surface; - // Create Surface - ASSERT(SDL_Vulkan_CreateSurface(createInfo.window, instance, nullptr, &surface)); + VkSurfaceKHR surface; + // Create Surface + ASSERT( SDL_Vulkan_CreateSurface(createInfo.window, instance, nullptr, &surface) ); - VkPhysicalDevice physicalDeviceInUse = nullptr; - VkDevice device = nullptr; - VmaAllocator gpuAllocator = nullptr; - std::optional directQueueFamilyIndex; - VkQueue directQueue = nullptr; - // Create Device and Queue - { - auto tempAllocStart = mem->getState(); + VkPhysicalDevice physicalDeviceInUse = nullptr; + VkDevice device = nullptr; + VmaAllocator gpuAllocator = nullptr; + std::optional directQueueFamilyIndex; + VkQueue directQueue = nullptr; + // Create Device and Queue + { + auto tempAllocStart = mem->getState(); - uint32_t physicalDeviceCount; - VK_CHECK(vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr)); - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "Found %u GPUs", physicalDeviceCount); + uint32_t physicalDeviceCount; + VK_CHECK( vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr) ); + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "Found %u GPUs", physicalDeviceCount ); - VkPhysicalDevice* physicalDevices = reinterpret_cast(mem->allocate(sizeof(VkPhysicalDevice) * physicalDeviceCount)); - VK_CHECK(vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices)); + VkPhysicalDevice* physicalDevices = reinterpret_cast(mem->allocate( + sizeof( VkPhysicalDevice ) * physicalDeviceCount )); + VK_CHECK( vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices) ); - for (VkPhysicalDevice const physicalDevice : std::span{ physicalDevices, physicalDeviceCount }) - { - auto tempAllocQueueProperties = mem->getState(); + for ( VkPhysicalDevice const physicalDevice : std::span{ physicalDevices, physicalDeviceCount } ) + { + auto tempAllocQueueProperties = mem->getState(); - VkPhysicalDeviceProperties properties; - vkGetPhysicalDeviceProperties(physicalDevice, &properties); + VkPhysicalDeviceProperties properties; + vkGetPhysicalDeviceProperties( physicalDevice, &properties ); - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "GPU: %s", properties.deviceName); + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "GPU: %s", properties.deviceName ); - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "- API Version %d.%d.%d", - VK_API_VERSION_MAJOR(properties.apiVersion), - VK_API_VERSION_MINOR(properties.apiVersion), - VK_API_VERSION_PATCH(properties.apiVersion)); + SDL_LogInfo( + SDL_LOG_CATEGORY_GPU, + "- API Version %d.%d.%d", + VK_API_VERSION_MAJOR( properties.apiVersion ), + VK_API_VERSION_MINOR( properties.apiVersion ), + VK_API_VERSION_PATCH( properties.apiVersion ) ); - constexpr static uint32_t API_PATCH_BITS = 0xFFF; - if ((properties.apiVersion & (~API_PATCH_BITS)) < VK_API_VERSION_1_3) - { - continue; - } + constexpr static uint32_t API_PATCH_BITS = 0xFFF; + if ( (properties.apiVersion & (~API_PATCH_BITS)) < VK_API_VERSION_1_3 ) + { + continue; + } - if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) - { - continue; - } + if ( properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU ) + { + continue; + } - uint32_t queueFamilyCount; - vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr); - VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast(mem->allocate(sizeof(VkQueueFamilyProperties) * queueFamilyCount)); - vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilyProperties); + uint32_t queueFamilyCount; + vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, nullptr ); + VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast(mem->allocate( + sizeof( VkQueueFamilyProperties ) * queueFamilyCount )); + vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, queueFamilyProperties ); - for (uint32_t queueFamilyIndex = 0; queueFamilyIndex != queueFamilyCount; - ++queueFamilyIndex) - { - VkQueueFamilyProperties const& qfp = queueFamilyProperties[queueFamilyIndex]; + for ( uint32_t queueFamilyIndex = 0; queueFamilyIndex != queueFamilyCount; + ++queueFamilyIndex ) + { + VkQueueFamilyProperties const& qfp = queueFamilyProperties[queueFamilyIndex]; - bool hasGraphicsSupport = false; - bool hasComputeSupport = false; - bool hasTransferSupport = false; - bool hasPresentSupport = false; + bool hasGraphicsSupport = false; + bool hasComputeSupport = false; + bool hasTransferSupport = false; + bool hasPresentSupport = false; - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "- Queue [%d]", queueFamilyIndex); - if (qfp.queueFlags & VK_QUEUE_GRAPHICS_BIT) - { - hasGraphicsSupport = true; - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Graphic"); - } - if (qfp.queueFlags & VK_QUEUE_COMPUTE_BIT) - { - hasComputeSupport = true; - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Compute"); - } - if (qfp.queueFlags & VK_QUEUE_TRANSFER_BIT) - { - hasTransferSupport = true; - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Transfer"); - } + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "- Queue [%d]", queueFamilyIndex ); + if ( qfp.queueFlags & VK_QUEUE_GRAPHICS_BIT ) + { + hasGraphicsSupport = true; + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Graphic" ); + } + if ( qfp.queueFlags & VK_QUEUE_COMPUTE_BIT ) + { + hasComputeSupport = true; + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Compute" ); + } + if ( qfp.queueFlags & VK_QUEUE_TRANSFER_BIT ) + { + hasTransferSupport = true; + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Transfer" ); + } - VkBool32 isSurfaceSupported; - VK_CHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported)); + VkBool32 isSurfaceSupported; + VK_CHECK( + vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported) ); - if (isSurfaceSupported) - { - hasPresentSupport = true; - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Present"); - } + if ( isSurfaceSupported ) + { + hasPresentSupport = true; + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Present" ); + } - if (hasGraphicsSupport and hasComputeSupport and hasTransferSupport and hasPresentSupport) - { - physicalDeviceInUse = physicalDevice; - directQueueFamilyIndex = queueFamilyIndex; - break; - } + if ( hasGraphicsSupport and hasComputeSupport and hasTransferSupport and hasPresentSupport ) + { + physicalDeviceInUse = physicalDevice; + directQueueFamilyIndex = queueFamilyIndex; + break; + } + } - } + mem->restoreState( tempAllocQueueProperties ); + } - mem->restoreState(tempAllocQueueProperties); - } + ASSERT( physicalDeviceInUse ); + ASSERT( directQueueFamilyIndex.has_value() ); - ASSERT(physicalDeviceInUse); - ASSERT(directQueueFamilyIndex.has_value()); + float priority = 1.0f; + VkDeviceQueueCreateInfo queueCreateInfo = { + .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .queueFamilyIndex = directQueueFamilyIndex.value(), + .queueCount = 1, + .pQueuePriorities = &priority, + }; - float priority = 1.0f; - VkDeviceQueueCreateInfo queueCreateInfo = { - .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .queueFamilyIndex = directQueueFamilyIndex.value(), - .queueCount = 1, - .pQueuePriorities = &priority, - }; + VkPhysicalDeviceVulkan13Features constexpr features13 = { + .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, + .pNext = nullptr, + .synchronization2 = true, + .dynamicRendering = true, + }; - VkPhysicalDeviceVulkan13Features constexpr features13 = { - .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, - .pNext = nullptr, - .synchronization2 = true, - .dynamicRendering = true, - }; + VkPhysicalDeviceFeatures features = { + .depthClamp = true, + .samplerAnisotropy = true, + }; - VkPhysicalDeviceFeatures features = { - .depthClamp = true, - .samplerAnisotropy = true, - }; + std::array enabledDeviceExtensions = { + VK_KHR_SWAPCHAIN_EXTENSION_NAME + }; - std::array enabledDeviceExtensions = { - VK_KHR_SWAPCHAIN_EXTENSION_NAME - }; + VkDeviceCreateInfo const deviceCreateInfo = { + .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + .pNext = &features13, + .flags = 0, + .queueCreateInfoCount = 1, + .pQueueCreateInfos = &queueCreateInfo, + .enabledLayerCount = 0, + .ppEnabledLayerNames = nullptr, + .enabledExtensionCount = static_cast(enabledDeviceExtensions.size()), + .ppEnabledExtensionNames = enabledDeviceExtensions.data(), + .pEnabledFeatures = &features, + }; - VkDeviceCreateInfo const deviceCreateInfo = { - .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - .pNext = &features13, - .flags = 0, - .queueCreateInfoCount = 1, - .pQueueCreateInfos = &queueCreateInfo, - .enabledLayerCount = 0, - .ppEnabledLayerNames = nullptr, - .enabledExtensionCount = static_cast(enabledDeviceExtensions.size()), - .ppEnabledExtensionNames = enabledDeviceExtensions.data(), - .pEnabledFeatures = &features, - }; + VK_CHECK( vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device) ); + volkLoadDevice( device ); - VK_CHECK(vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device)); - volkLoadDevice(device); + VmaAllocatorCreateInfo allocatorCreateInfo = { + .flags = 0, + .physicalDevice = physicalDeviceInUse, + .device = device, + .preferredLargeHeapBlockSize = 0, + .pAllocationCallbacks = nullptr, + .pDeviceMemoryCallbacks = nullptr, + .pHeapSizeLimit = nullptr, + .pVulkanFunctions = nullptr, + .instance = instance, + .vulkanApiVersion = VK_API_VERSION_1_3, + .pTypeExternalMemoryHandleTypes = nullptr, + }; - VmaAllocatorCreateInfo allocatorCreateInfo = { - .flags = 0, - .physicalDevice = physicalDeviceInUse, - .device = device, - .preferredLargeHeapBlockSize = 0, - .pAllocationCallbacks = nullptr, - .pDeviceMemoryCallbacks = nullptr, - .pHeapSizeLimit = nullptr, - .pVulkanFunctions = nullptr, - .instance = instance, - .vulkanApiVersion = VK_API_VERSION_1_3, - .pTypeExternalMemoryHandleTypes = nullptr, - }; + VmaVulkanFunctions vkFunctions; + VK_CHECK( vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions) ); + allocatorCreateInfo.pVulkanFunctions = &vkFunctions; - VmaVulkanFunctions vkFunctions; - VK_CHECK(vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions)); - allocatorCreateInfo.pVulkanFunctions = &vkFunctions; + VK_CHECK( vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator) ); - VK_CHECK(vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator)); + vkGetDeviceQueue( device, directQueueFamilyIndex.value(), 0, &directQueue ); - vkGetDeviceQueue(device, directQueueFamilyIndex.value(), 0, &directQueue); + mem->restoreState( tempAllocStart ); + } - mem->restoreState(tempAllocStart); - } + // Swapchain creation + VkExtent2D swapchainExtent = { createInfo.width, createInfo.height }; + VkFormat swapchainFormat = VK_FORMAT_UNDEFINED; + VkSwapchainKHR swapchain; + VkImage* swapchainImages; + VkImageView* swapchainViews; + uint32_t swapchainImageCount; + { + auto tempAllocStart = mem->getState(); - // Swapchain creation - VkExtent2D swapchainExtent = { createInfo.width, createInfo.height }; - VkFormat swapchainFormat = VK_FORMAT_UNDEFINED; - VkSwapchainKHR swapchain; - VkImage* swapchainImages; - VkImageView* swapchainViews; - uint32_t swapchainImageCount; - { - auto tempAllocStart = mem->getState(); + VkSurfaceCapabilitiesKHR capabilities; + VK_CHECK( vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities) ); - VkSurfaceCapabilitiesKHR capabilities; - VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities)); + // Image Count Calculation + swapchainImageCount = 3; + if ( capabilities.maxImageCount > 0 ) + { + swapchainImageCount = std::min( swapchainImageCount, capabilities.maxImageCount ); + } + swapchainImageCount = std::max( swapchainImageCount, capabilities.minImageCount + 1 ); - // Image Count Calculation - swapchainImageCount = 3; - if (capabilities.maxImageCount > 0) - { - swapchainImageCount = std::min(swapchainImageCount, capabilities.maxImageCount); - } - swapchainImageCount = std::max(swapchainImageCount, capabilities.minImageCount + 1); + // Image Size calculation + { + auto [minWidth, minHeight] = capabilities.minImageExtent; + auto [maxWidth, maxHeight] = capabilities.maxImageExtent; + swapchainExtent.width = Clamp( swapchainExtent.width, minWidth, maxWidth ); + swapchainExtent.height = Clamp( swapchainExtent.height, minHeight, maxHeight ); + } - // Image Size calculation - { - auto [minWidth, minHeight] = capabilities.minImageExtent; - auto [maxWidth, maxHeight] = capabilities.maxImageExtent; - swapchainExtent.width = Clamp(swapchainExtent.width, minWidth, maxWidth); - swapchainExtent.height = Clamp(swapchainExtent.height, minHeight, maxHeight); - } + uint32_t surfaceFormatCount; + vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, nullptr ); + VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast(mem->allocate( + sizeof( VkSurfaceFormatKHR* ) * surfaceFormatCount )); + vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats ); - uint32_t surfaceFormatCount; - vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, nullptr); - VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast(mem->allocate(sizeof(VkSurfaceFormatKHR*) * surfaceFormatCount)); - vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats); + VkSurfaceFormatKHR format = { + .format = VK_FORMAT_UNDEFINED, + .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + }; + for ( auto& surfaceFormat : std::span{ surfaceFormats, surfaceFormatCount } ) + { + if ( surfaceFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR ) + { + SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "Color Space SRGB Found %d", surfaceFormat.format ); + if ( surfaceFormat.format == VK_FORMAT_R8G8B8A8_SRGB ) + { + format = surfaceFormat; + break; + } + if ( surfaceFormat.format == VK_FORMAT_B8G8R8A8_SRGB ) + { + format = surfaceFormat; + break; + } + if ( surfaceFormat.format == VK_FORMAT_R8G8B8A8_UNORM ) + { + format = surfaceFormat; + } + } + } + ASSERT( format.format != VK_FORMAT_UNDEFINED ); + swapchainFormat = format.format; - VkSurfaceFormatKHR format = { - .format = VK_FORMAT_UNDEFINED, - .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - }; - for (auto& surfaceFormat : std::span{ surfaceFormats, surfaceFormatCount }) - { - if (surfaceFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) - { - SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "Color Space SRGB Found %d", surfaceFormat.format); - if (surfaceFormat.format == VK_FORMAT_R8G8B8A8_SRGB) { - format = surfaceFormat; - break; - } - if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_SRGB) { - format = surfaceFormat; - break; - } - if (surfaceFormat.format == VK_FORMAT_R8G8B8A8_UNORM) { - format = surfaceFormat; - } - } - } - ASSERT(format.format != VK_FORMAT_UNDEFINED); - swapchainFormat = format.format; + uint32_t presentModeCount; + vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, nullptr ); + VkPresentModeKHR* presentModes = reinterpret_cast(mem->allocate( + sizeof( VkPresentModeKHR* ) * presentModeCount )); + vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, presentModes ); - uint32_t presentModeCount; - vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, nullptr); - VkPresentModeKHR* presentModes = reinterpret_cast(mem->allocate(sizeof(VkPresentModeKHR*) * presentModeCount)); - vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, presentModes); + VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; + for ( VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount } ) + { + if ( presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR ) + { + presentMode = presentModeIter; + break; + } - VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; - for (VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount }) - { - if (presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR) - { - presentMode = presentModeIter; - break; - } + if ( presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR ) + { + presentMode = presentModeIter; + } + } - if (presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR) - { - presentMode = presentModeIter; - } - } + mem->restoreState( tempAllocStart ); - mem->restoreState(tempAllocStart); + VkSwapchainCreateInfoKHR const swapchainCreateInfo = { + .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + .pNext = nullptr, + .flags = 0, + .surface = surface, + .minImageCount = swapchainImageCount, + .imageFormat = format.format, + .imageColorSpace = format.colorSpace, + .imageExtent = swapchainExtent, + .imageArrayLayers = 1, + .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE, + .queueFamilyIndexCount = 0, + .pQueueFamilyIndices = nullptr, + .preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, + .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + .presentMode = presentMode, + .clipped = false, + .oldSwapchain = nullptr, + }; - VkSwapchainCreateInfoKHR const swapchainCreateInfo = { - .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, - .pNext = nullptr, - .flags = 0, - .surface = surface, - .minImageCount = swapchainImageCount, - .imageFormat = format.format, - .imageColorSpace = format.colorSpace, - .imageExtent = swapchainExtent, - .imageArrayLayers = 1, - .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE, - .queueFamilyIndexCount = 0, - .pQueueFamilyIndices = nullptr, - .preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, - .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - .presentMode = presentMode, - .clipped = false, - .oldSwapchain = nullptr, - }; + VK_CHECK( vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr, &swapchain) ); - VK_CHECK(vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr, &swapchain)); + swapchainImageCount = 0; + vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, nullptr ); + swapchainImages = reinterpret_cast(mem->allocate( sizeof( VkImage ) * swapchainImageCount )); + vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, swapchainImages ); - swapchainImageCount = 0; - vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, nullptr); - swapchainImages = reinterpret_cast(mem->allocate(sizeof(VkImage) * swapchainImageCount)); - vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, swapchainImages); + swapchainViews = reinterpret_cast(mem->allocate( sizeof( VkImageView ) * swapchainImageCount )); + for ( uint32_t i = 0; i != swapchainImageCount; ++i ) + { + VkImageViewCreateInfo const viewCreateInfo = { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .image = swapchainImages[i], + .viewType = VK_IMAGE_VIEW_TYPE_2D, + .format = format.format, + .components = { + VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_IDENTITY + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .levelCount = 1, + .baseArrayLayer = 0, + .layerCount = 1, + } + }; - swapchainViews = reinterpret_cast(mem->allocate(sizeof(VkImageView) * swapchainImageCount)); - for (uint32_t i = 0; i != swapchainImageCount; ++i) { - VkImageViewCreateInfo const viewCreateInfo = { - .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .image = swapchainImages[i], - .viewType = VK_IMAGE_VIEW_TYPE_2D, - .format = format.format, - .components = { - VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_IDENTITY - }, - .subresourceRange = { - .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, - .baseMipLevel = 0, - .levelCount = 1, - .baseArrayLayer = 0, - .layerCount = 1, - } - }; + VK_CHECK( vkCreateImageView(device, &viewCreateInfo, nullptr, &swapchainViews[i]) ); + } + } - VK_CHECK(vkCreateImageView(device, &viewCreateInfo, nullptr, &swapchainViews[i])); - } - } + // Init frames. - // Init frames. + Frame* frames = reinterpret_cast(mem->allocate( sizeof( Frame ) * swapchainImageCount )); + for ( uint32_t i = 0; i != swapchainImageCount; ++i ) + { + new( frames + i ) Frame( device, directQueueFamilyIndex.value() ); + } - Frame* frames = reinterpret_cast(mem->allocate(sizeof(Frame) * swapchainImageCount)); - for (uint32_t i = 0; i != swapchainImageCount; ++i) - { - new (frames + i) Frame(device, directQueueFamilyIndex.value()); - } - - Byte* allocation = mem->allocate(sizeof(RenderDevice), alignof(RenderDevice)); - return new (allocation) RenderDevice{ - instance, surface, physicalDeviceInUse, - device, gpuAllocator, directQueue, directQueueFamilyIndex.value(), - swapchainFormat, swapchainExtent, swapchain, swapchainImages, swapchainViews, frames, swapchainImageCount, - }; + Byte* allocation = mem->allocate( sizeof( RenderDevice ), alignof( RenderDevice ) ); + return new( allocation ) RenderDevice{ + instance, + surface, + physicalDeviceInUse, + device, + gpuAllocator, + directQueue, + directQueueFamilyIndex.value(), + swapchainFormat, + swapchainExtent, + swapchain, + swapchainImages, + swapchainViews, + frames, + swapchainImageCount, + }; } inline bool RenderDevice::isInit() const { - return instance and device; + return instance and device; } -void RenderDevice::cleanup() +void RenderDevice::destroy() { - if (not isInit()) - return; + if ( not isInit() ) return; - for (Frame& frame : std::span{ frames, swapchainImageCount }) - { - frame.cleanup(*this); - } + for ( Frame& frame : std::span{ frames, swapchainImageCount } ) + { + frame.destroy( *this ); + } - for (auto const& view : std::span{ swapchainViews, swapchainImageCount }) - { - vkDestroyImageView(device, view, nullptr); - } + for ( auto const& view : std::span{ swapchainViews, swapchainImageCount } ) + { + vkDestroyImageView( device, view, nullptr ); + } - vkDestroySwapchainKHR(device, Take(swapchain), nullptr); + vkDestroySwapchainKHR( device, Take( swapchain ), nullptr ); - vkDestroyDevice(Take(device), nullptr); + vkDestroyDevice( Take( device ), nullptr ); - SDL_Vulkan_DestroySurface(instance, Take(surface), nullptr); + SDL_Vulkan_DestroySurface( instance, Take( surface ), nullptr ); - vkDestroyInstance(Take(instance), nullptr); + vkDestroyInstance( Take( instance ), nullptr ); - volkFinalize(); + volkFinalize(); } void RenderDevice::waitIdle() const { - VK_CHECK(vkDeviceWaitIdle(device)); + VK_CHECK( vkDeviceWaitIdle(device) ); } uint32_t RenderDevice::getNumFrames() const { - return swapchainImageCount; + return swapchainImageCount; } -RenderDevice::RenderDevice(VkInstance const instance, VkSurfaceKHR const surface, VkPhysicalDevice const physicalDeviceInUse, - VkDevice const device, VmaAllocator gpuAllocator, VkQueue const directQueue, uint32_t const directQueueFamilyIndex, - VkFormat const swapchainFormat, VkExtent2D const swapchainExtent, VkSwapchainKHR const swapchain, VkImage* swapchainImages, - VkImageView* swapchainViews, Frame* frames, uint32_t const swapchainImageCount) - : instance{ instance } - , surface{ surface } - , physicalDeviceInUse{ physicalDeviceInUse } - , device{ device } - , gpuAllocator{ gpuAllocator } - , directQueue{ directQueue } - , directQueueFamilyIndex{ directQueueFamilyIndex } - , swapchainFormat{ swapchainFormat } - , swapchainExtent{ swapchainExtent } - , swapchain{ swapchain } - , swapchainImages{ swapchainImages } - , swapchainViews{ swapchainViews } - , frames{ frames } - , swapchainImageCount{ swapchainImageCount } -{ -} +RenderDevice::RenderDevice( + VkInstance const instance, + VkSurfaceKHR const surface, + VkPhysicalDevice const physicalDeviceInUse, + VkDevice const device, + VmaAllocator gpuAllocator, + VkQueue const directQueue, + uint32_t const directQueueFamilyIndex, + VkFormat const swapchainFormat, + VkExtent2D const swapchainExtent, + VkSwapchainKHR const swapchain, + VkImage* swapchainImages, + VkImageView* swapchainViews, + Frame* frames, + uint32_t const swapchainImageCount ) + : instance{ instance } + , surface{ surface } + , physicalDeviceInUse{ physicalDeviceInUse } + , device{ device } + , gpuAllocator{ gpuAllocator } + , directQueue{ directQueue } + , directQueueFamilyIndex{ directQueueFamilyIndex } + , swapchainFormat{ swapchainFormat } + , swapchainExtent{ swapchainExtent } + , swapchain{ swapchain } + , swapchainImages{ swapchainImages } + , swapchainViews{ swapchainViews } + , frames{ frames } + , swapchainImageCount{ swapchainImageCount } {} diff --git a/RenderDevice.h b/RenderDevice.h index b49bf5d..f93db1c 100644 --- a/RenderDevice.h +++ b/RenderDevice.h @@ -18,63 +18,63 @@ struct Frame; /// TODO: Fail elegantly. struct RenderDevice { - struct CreateInfo - { - SDL_Window* window = nullptr; - uint32_t width = 640; - uint32_t height = 480; - }; + struct CreateInfo + { + SDL_Window* window = nullptr; + uint32_t width = 640; + uint32_t height = 480; + }; - VkInstance instance; - VkSurfaceKHR surface; - VkPhysicalDevice physicalDeviceInUse; + VkInstance instance; + VkSurfaceKHR surface; + VkPhysicalDevice physicalDeviceInUse; - VkDevice device; - VmaAllocator gpuAllocator; - VkQueue directQueue; - uint32_t directQueueFamilyIndex; + VkDevice device; + VmaAllocator gpuAllocator; + VkQueue directQueue; + uint32_t directQueueFamilyIndex; - VkFormat swapchainFormat; - VkExtent2D swapchainExtent; - VkSwapchainKHR swapchain; - VkImage* swapchainImages; - VkImageView* swapchainViews; - Frame* frames; - uint32_t swapchainImageCount; - uint32_t frameIndex = 0; + VkFormat swapchainFormat; + VkExtent2D swapchainExtent; + VkSwapchainKHR swapchain; + VkImage* swapchainImages; + VkImageView* swapchainViews; + Frame* frames; + uint32_t swapchainImageCount; + uint32_t frameIndex = 0; - [[nodiscard]] bool isInit() const; - void cleanup(); - void waitIdle() const; - [[nodiscard]] uint32_t getNumFrames() const; + [[nodiscard]] bool isInit() const; + void destroy(); + void waitIdle() const; + [[nodiscard]] uint32_t getNumFrames() const; - RenderDevice( - VkInstance instance, - VkSurfaceKHR surface, - VkPhysicalDevice physicalDeviceInUse, - VkDevice device, - VmaAllocator gpuAllocator, - VkQueue directQueue, - uint32_t directQueueFamilyIndex, - // TODO: Pack? + RenderDevice( + VkInstance instance, + VkSurfaceKHR surface, + VkPhysicalDevice physicalDeviceInUse, + VkDevice device, + VmaAllocator gpuAllocator, + VkQueue directQueue, + uint32_t directQueueFamilyIndex, + // TODO: Pack? - VkFormat swapchainFormat, - VkExtent2D swapchainExtent, - VkSwapchainKHR swapchain, + VkFormat swapchainFormat, + VkExtent2D swapchainExtent, + VkSwapchainKHR swapchain, - VkImage* swapchainImages, - VkImageView* swapchainViews, - Frame* frames, - uint32_t swapchainImageCount - ); + VkImage* swapchainImages, + VkImageView* swapchainViews, + Frame* frames, + uint32_t swapchainImageCount + ); - RenderDevice(RenderDevice const&) = delete; - RenderDevice& operator=(RenderDevice const&) = delete; + RenderDevice( RenderDevice const& ) = delete; + RenderDevice& operator=( RenderDevice const& ) = delete; - RenderDevice(RenderDevice&&) noexcept = delete; - RenderDevice& operator=(RenderDevice&&) noexcept = delete; + RenderDevice( RenderDevice&& ) noexcept = delete; + RenderDevice& operator=( RenderDevice&& ) noexcept = delete; - ~RenderDevice(); + ~RenderDevice(); }; -RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo); \ No newline at end of file +RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo ); diff --git a/VmaImpl.cpp b/VmaImpl.cpp index 7cf3063..afd73d4 100644 --- a/VmaImpl.cpp +++ b/VmaImpl.cpp @@ -4,4 +4,4 @@ #pragma warning(disable : 5045) #define VMA_IMPLEMENTATION #include -#pragma warning(pop) \ No newline at end of file +#pragma warning(pop)