kidrigger
/
Blaze
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Major Cleanup.

This commit is contained in:
Anish Bhobe 2025-06-12 23:37:07 +02:00
parent e7d74e6b0f
commit 9fe2815ab4
17 changed files with 956 additions and 928 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
AppState.cpp
View File

@ -3,15 +3,15 @@
#include <SDL3/SDL_log.h> #include <SDL3/SDL_log.h>
#include "GlobalMemory.h" #include "GlobalMemory.h"
#include "RenderDevice.h"
#include "MiscData.h" #include "MiscData.h"
#include "RenderDevice.h"
bool AppState::isInit() const bool AppState::isInit() const
{ {
return window and renderDevice and renderDevice->isInit(); return window and renderDevice and renderDevice->isInit();
} }
void AppState::cleanup() void AppState::destroy()
{ {
if (!isInit()) return; if (!isInit()) return;
@ -19,26 +19,30 @@ void AppState::cleanup()
Take(miscData)->cleanup(*renderDevice); Take(miscData)->cleanup(*renderDevice);
Take(renderDevice)->cleanup(); Take(renderDevice)->destroy();
SDL_DestroyWindow(Take(window)); 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 } , renderDevice{ renderDevice }
, miscData{ miscData } , miscData{ miscData } {
{
} }
AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t const height) AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t const height)
{ {
SDL_Window* window = SDL_CreateWindow("Blaze Test", static_cast<int>(width), static_cast<int>(height), SDL_WINDOW_VULKAN); SDL_Window* window = SDL_CreateWindow(
"Blaze Test",
static_cast<int>(width),
static_cast<int>(height),
SDL_WINDOW_VULKAN);
if (!window) if (!window)
{ {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s", SDL_GetError()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s", SDL_GetError());
return nullptr; return nullptr;
} }
auto state = memory->getState(); auto state = memory->getState();
RenderDevice* renderDevice = CreateRenderDevice(memory, { .window = window }); RenderDevice* renderDevice = CreateRenderDevice(memory, { .window = window });
if (!renderDevice->isInit()) if (!renderDevice->isInit())
{ {
@ -49,16 +53,16 @@ AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t co
auto* miscDataAllocation = memory->allocate(sizeof(MiscData)); auto* miscDataAllocation = memory->allocate(sizeof(MiscData));
MiscData* miscData = new (miscDataAllocation) MiscData{}; MiscData* miscData = new(miscDataAllocation) MiscData{};
miscData->init(*renderDevice); miscData->init(*renderDevice);
auto* allocation = memory->allocate(sizeof(AppState)); auto* allocation = memory->allocate(sizeof(AppState));
AppState* appState = new (allocation) AppState{ window, renderDevice, miscData }; AppState* appState = new(allocation) AppState{ window, renderDevice, miscData };
return appState; return appState;
} }
AppState::~AppState() AppState::~AppState()
{ {
cleanup(); ASSERT(!isInit());
} }

28
AppState.h
View File

@ -2,29 +2,31 @@
#include <memory> #include <memory>
struct GlobalMemory;
struct SDL_Window; struct SDL_Window;
struct GlobalMemory;
struct RenderDevice; struct RenderDevice;
struct MiscData; struct MiscData;
struct AppState struct AppState
{ {
SDL_Window* window; SDL_Window* window;
RenderDevice* renderDevice; RenderDevice* renderDevice;
MiscData* miscData; MiscData* miscData;
[[nodiscard]] bool isInit() const; [[nodiscard]]
void cleanup(); 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 const& other ) = delete;
AppState(AppState&& other) noexcept = delete; AppState( AppState&& other ) noexcept = delete;
AppState& operator=(AppState const& other) = delete; AppState& operator=( AppState const& other ) = delete;
AppState& operator=(AppState&& other) noexcept = 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 );

266
Blaze.cpp
View File

@ -23,187 +23,189 @@
#include "RenderDevice.h" #include "RenderDevice.h"
#include "MiscData.h" #include "MiscData.h"
constexpr uint32_t WIDTH = 1280; constexpr uint32_t WIDTH = 1280;
constexpr uint32_t HEIGHT = 720; constexpr uint32_t HEIGHT = 720;
constexpr uint32_t NUM_FRAMES = 3; constexpr uint32_t NUM_FRAMES = 3;
using Byte = uint8_t; 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 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); *pAppState = CreateAppState( &Blaze::Global::g_Memory, WIDTH, HEIGHT );
if (!*pAppState) if ( !*pAppState ) return SDL_APP_FAILURE;
return SDL_APP_FAILURE;
AppState& appState = *static_cast<AppState*>(*pAppState); AppState& appState = *static_cast<AppState*>(*pAppState);
if (!appState.isInit()) if ( !appState.isInit() )
{ {
return SDL_APP_FAILURE; 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*>(appstate); AppState& appState = *static_cast<AppState*>(appstate);
RenderDevice& renderDevice = *appState.renderDevice; RenderDevice& renderDevice = *appState.renderDevice;
MiscData& misc = *appState.miscData; MiscData& misc = *appState.miscData;
Frame& currentFrame = renderDevice.frames[renderDevice.frameIndex]; Frame& currentFrame = renderDevice.frames[renderDevice.frameIndex];
VK_CHECK(vkWaitForFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse, VK_TRUE, std::numeric_limits<uint32_t>::max())); VK_CHECK(
// All resources of frame 'frameIndex' are free. vkWaitForFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse, VK_TRUE, std::numeric_limits<uint32_t>::max
()) );
// All resources of frame 'frameIndex' are free.
uint32_t currentImageIndex; uint32_t currentImageIndex;
VK_CHECK(vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits<uint32_t>::max(), currentFrame.imageAcquiredSemaphore, nullptr, &currentImageIndex)); VK_CHECK(
vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits<uint32_t>::max(),
currentFrame.imageAcquiredSemaphore, nullptr, &currentImageIndex) );
VK_CHECK(vkResetFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse)); VK_CHECK( vkResetFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse) );
VK_CHECK(vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0)); VK_CHECK( vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0) );
misc.acquireToRenderBarrier.image = renderDevice.swapchainImages[currentImageIndex]; misc.acquireToRenderBarrier.image = renderDevice.swapchainImages[currentImageIndex];
misc.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex]; misc.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex];
VkCommandBuffer cmd = currentFrame.commandBuffer; VkCommandBuffer cmd = currentFrame.commandBuffer;
VkCommandBufferBeginInfo constexpr beginInfo = { VkCommandBufferBeginInfo constexpr beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.pInheritanceInfo = nullptr, .pInheritanceInfo = nullptr,
}; };
VkClearColorValue constexpr static BLACK_CLEAR = { VkClearColorValue constexpr static BLACK_CLEAR = {
.float32 = { 0.0f, 0.0f, 0.0f, 1.0f }, .float32 = { 0.0f, 0.0f, 0.0f, 1.0f },
}; };
VK_CHECK(vkBeginCommandBuffer(cmd, &beginInfo)); VK_CHECK( vkBeginCommandBuffer(cmd, &beginInfo) );
{ {
VkRenderingAttachmentInfo const attachmentInfo = { VkRenderingAttachmentInfo const attachmentInfo = {
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
.pNext = nullptr, .pNext = nullptr,
.imageView = renderDevice.swapchainViews[currentImageIndex], .imageView = renderDevice.swapchainViews[currentImageIndex],
.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, .imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.resolveMode = VK_RESOLVE_MODE_NONE, .resolveMode = VK_RESOLVE_MODE_NONE,
.resolveImageView = nullptr, .resolveImageView = nullptr,
.resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED, .resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR, .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE, .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.clearValue = {.color = BLACK_CLEAR}, .clearValue = { .color = BLACK_CLEAR },
}; };
VkRenderingInfo renderingInfo = { VkRenderingInfo renderingInfo = {
.sType = VK_STRUCTURE_TYPE_RENDERING_INFO, .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.renderArea = {.offset = {0,0}, .extent = renderDevice.swapchainExtent}, .renderArea = { .offset = { 0, 0 }, .extent = renderDevice.swapchainExtent },
.layerCount = 1, .layerCount = 1,
.viewMask = 0, .viewMask = 0,
.colorAttachmentCount = 1, .colorAttachmentCount = 1,
.pColorAttachments = &attachmentInfo, .pColorAttachments = &attachmentInfo,
.pDepthAttachment = nullptr, .pDepthAttachment = nullptr,
.pStencilAttachment = nullptr, .pStencilAttachment = nullptr,
}; };
vkCmdPipelineBarrier2(cmd, &misc.acquireToRenderDependency); vkCmdPipelineBarrier2( cmd, &misc.acquireToRenderDependency );
vkCmdBeginRendering(cmd, &renderingInfo); vkCmdBeginRendering( cmd, &renderingInfo );
{ {
VkViewport viewport = { VkViewport viewport = {
.x = 0, .x = 0,
.y = static_cast<float>(renderDevice.swapchainExtent.height), .y = static_cast<float>(renderDevice.swapchainExtent.height),
.width = static_cast<float>(renderDevice.swapchainExtent.width), .width = static_cast<float>(renderDevice.swapchainExtent.width),
.height = -static_cast<float>(renderDevice.swapchainExtent.height), .height = -static_cast<float>(renderDevice.swapchainExtent.height),
.minDepth = 0.0f, .minDepth = 0.0f,
.maxDepth = 1.0f, .maxDepth = 1.0f,
}; };
vkCmdSetViewport(cmd, 0, 1, &viewport); vkCmdSetViewport( cmd, 0, 1, &viewport );
VkRect2D scissor = { VkRect2D scissor = {
.offset = {0, 0}, .offset = { 0, 0 },
.extent = renderDevice.swapchainExtent, .extent = renderDevice.swapchainExtent,
}; };
vkCmdSetScissor(cmd, 0, 1, &scissor); vkCmdSetScissor( cmd, 0, 1, &scissor );
// Render Something? // Render Something?
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline); vkCmdBindPipeline( cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline );
vkCmdDraw(cmd, 3, 1, 0, 0); vkCmdDraw( cmd, 3, 1, 0, 0 );
}
vkCmdEndRendering( cmd );
vkCmdPipelineBarrier2( cmd, &misc.renderToPresentDependency );
}
VK_CHECK( vkEndCommandBuffer(cmd) );
} VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
vkCmdEndRendering(cmd); VkSubmitInfo const submitInfo = {
vkCmdPipelineBarrier2(cmd, &misc.renderToPresentDependency); .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
} .pNext = nullptr,
VK_CHECK(vkEndCommandBuffer(cmd)); .waitSemaphoreCount = 1,
.pWaitSemaphores = &currentFrame.imageAcquiredSemaphore,
.pWaitDstStageMask = &stageMask,
.commandBufferCount = 1,
.pCommandBuffers = &cmd,
.signalSemaphoreCount = 1,
.pSignalSemaphores = &currentFrame.renderFinishedSemaphore,
};
VK_CHECK( vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse) );
VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; VkPresentInfoKHR const presentInfo = {
VkSubmitInfo const submitInfo = { .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .pNext = nullptr,
.pNext = nullptr, .waitSemaphoreCount = 1,
.waitSemaphoreCount = 1, .pWaitSemaphores = &currentFrame.renderFinishedSemaphore,
.pWaitSemaphores = &currentFrame.imageAcquiredSemaphore, .swapchainCount = 1,
.pWaitDstStageMask = &stageMask, .pSwapchains = &renderDevice.swapchain,
.commandBufferCount = 1, .pImageIndices = &currentImageIndex,
.pCommandBuffers = &cmd, .pResults = nullptr,
.signalSemaphoreCount = 1, };
.pSignalSemaphores = &currentFrame.renderFinishedSemaphore,
};
VK_CHECK(vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse));
VkPresentInfoKHR const presentInfo = { VK_CHECK( vkQueuePresentKHR(renderDevice.directQueue, &presentInfo) );
.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.pNext = nullptr,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &currentFrame.renderFinishedSemaphore,
.swapchainCount = 1,
.pSwapchains = &renderDevice.swapchain,
.pImageIndices = &currentImageIndex,
.pResults = nullptr,
};
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) if ( event->type == SDL_EVENT_QUIT )
{ {
return SDL_APP_SUCCESS; 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* appState = static_cast<AppState*>(appstate);
appState->cleanup(); appState->destroy();
Blaze::Global::g_Memory.destroy(); Blaze::Global::g_Memory.destroy();
} }

1
Blaze.vcxproj
View File

@ -183,7 +183,6 @@
<ClInclude Include="AppState.h" /> <ClInclude Include="AppState.h" />
<ClInclude Include="Frame.h" /> <ClInclude Include="Frame.h" />
<ClInclude Include="GlobalMemory.h" /> <ClInclude Include="GlobalMemory.h" />
<ClInclude Include="MemoryUtils.h" />
<ClInclude Include="MacroUtils.h" /> <ClInclude Include="MacroUtils.h" />
<ClInclude Include="MathUtil.h" /> <ClInclude Include="MathUtil.h" />
<ClInclude Include="MiscData.h" /> <ClInclude Include="MiscData.h" />

3
Blaze.vcxproj.filters
View File

@ -75,9 +75,6 @@
<ClInclude Include="MathUtil.h"> <ClInclude Include="MathUtil.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="MemoryUtils.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="AppState.h"> <ClInclude Include="AppState.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>

78
Frame.cpp
View File

@ -7,58 +7,58 @@
bool Frame::isInit() const bool Frame::isInit() const
{ {
return static_cast<bool>(commandPool); return static_cast<bool>(commandPool);
} }
Frame::Frame(VkDevice const device, uint32_t const directQueueFamilyIndex) Frame::Frame( VkDevice const device, uint32_t const directQueueFamilyIndex )
{ {
VkCommandPoolCreateInfo const commandPoolCreateInfo = { VkCommandPoolCreateInfo const commandPoolCreateInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, .flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
.queueFamilyIndex = directQueueFamilyIndex, .queueFamilyIndex = directQueueFamilyIndex,
}; };
VK_CHECK(vkCreateCommandPool(device, &commandPoolCreateInfo, nullptr, &commandPool)); VK_CHECK( vkCreateCommandPool(device, &commandPoolCreateInfo, nullptr, &commandPool) );
VkCommandBufferAllocateInfo const commandBufferAllocateInfo = { VkCommandBufferAllocateInfo const commandBufferAllocateInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.commandPool = commandPool, .commandPool = commandPool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1, .commandBufferCount = 1,
}; };
VK_CHECK(vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer)); VK_CHECK( vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer) );
VkSemaphoreCreateInfo constexpr semaphoreCreateInfo = { VkSemaphoreCreateInfo constexpr semaphoreCreateInfo = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0 .flags = 0
}; };
VK_CHECK(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &imageAcquiredSemaphore)); VK_CHECK( vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &imageAcquiredSemaphore) );
VK_CHECK(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &renderFinishedSemaphore)); VK_CHECK( vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &renderFinishedSemaphore) );
VkFenceCreateInfo constexpr fenceCreateInfo = { VkFenceCreateInfo constexpr fenceCreateInfo = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = VK_FENCE_CREATE_SIGNALED_BIT, .flags = VK_FENCE_CREATE_SIGNALED_BIT,
}; };
VK_CHECK(vkCreateFence(device, &fenceCreateInfo, nullptr, &frameReadyToReuse)); 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); vkDestroyCommandPool( device, Take( commandPool ), nullptr );
vkDestroyFence(device, Take(frameReadyToReuse), nullptr); vkDestroyFence( device, Take( frameReadyToReuse ), nullptr );
vkDestroySemaphore(device, Take(imageAcquiredSemaphore), nullptr); vkDestroySemaphore( device, Take( imageAcquiredSemaphore ), nullptr );
vkDestroySemaphore(device, Take(renderFinishedSemaphore), nullptr); vkDestroySemaphore( device, Take( renderFinishedSemaphore ), nullptr );
} }
Frame::~Frame() Frame::~Frame()
{ {
// Manual Cleanup Required. // Manual Cleanup Required.
ASSERT(not isInit()); ASSERT( not isInit() );
} }

19
Frame.h
View File

@ -7,18 +7,17 @@ struct RenderDevice;
struct Frame struct Frame
{ {
VkCommandPool commandPool; VkCommandPool commandPool;
VkCommandBuffer commandBuffer; VkCommandBuffer commandBuffer;
VkSemaphore imageAcquiredSemaphore; VkSemaphore imageAcquiredSemaphore;
VkSemaphore renderFinishedSemaphore; VkSemaphore renderFinishedSemaphore;
VkFence frameReadyToReuse; 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();
}; };

80
GlobalMemory.cpp
View File

@ -2,64 +2,70 @@
#include <SDL3/SDL_log.h> #include <SDL3/SDL_log.h>
void GlobalMemory::init(size_t const size) void GlobalMemory::init( size_t const size )
{ {
memory = new Byte[size]; memory = new Byte[size];
capacity = size; capacity = size;
available = size; available = size;
} }
void GlobalMemory::destroy() void GlobalMemory::destroy()
{ {
Byte const* originalMemory = memory - (capacity - available); Byte const* originalMemory = memory - (capacity - available);
delete[] originalMemory; delete[] originalMemory;
memory = nullptr; memory = nullptr;
available = 0; available = 0;
capacity = 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; Byte* retVal = memory;
memory += size; memory += size;
available -= size; available -= size;
SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "ALLOC: %p -> %p (%llu) (avail: %llu)", reinterpret_cast<void*>(retVal), reinterpret_cast<void*>(memory), size, available); SDL_LogInfo(
SDL_LOG_CATEGORY_SYSTEM,
"ALLOC: %p -> %p (%llu) (avail: %llu)",
reinterpret_cast<void*>(retVal),
reinterpret_cast<void*>(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<uintptr_t>(memory); uintptr_t const addr = reinterpret_cast<uintptr_t>(memory);
uintptr_t const foundOffset = addr % alignment; uintptr_t const foundOffset = addr % alignment;
if (foundOffset == 0) if ( foundOffset == 0 )
{ {
return allocate(size); return allocate( size );
} }
uintptr_t const offset = alignment - foundOffset; uintptr_t const offset = alignment - foundOffset;
size_t const allocationSize = size + offset; size_t const allocationSize = size + offset;
return offset + allocate(allocationSize); return offset + allocate( allocationSize );
} }
GlobalMemory::State GlobalMemory::getState() const GlobalMemory::State GlobalMemory::getState() const
{ {
SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "TEMP: %p %llu", reinterpret_cast<void*>(memory), available); SDL_LogInfo( SDL_LOG_CATEGORY_SYSTEM, "TEMP: %p %llu", reinterpret_cast<void*>(memory), available );
return { return {
.memory = memory, .memory = memory,
.available = available, .available = available,
}; };
} }
void GlobalMemory::restoreState(State const& state) void GlobalMemory::restoreState( State const& state )
{ {
assert(memory >= state.memory); //< Behind top of allocator ASSERT( memory >= state.memory ); //< Behind top of allocator
assert(memory - (capacity - available) <= state.memory); //< Ahead of start of allocator ASSERT( memory - (capacity - available) <= state.memory ); //< Ahead of start of allocator
SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "RESTORE: %p %llu", reinterpret_cast<void*>(memory), available); SDL_LogInfo( SDL_LOG_CATEGORY_SYSTEM, "RESTORE: %p %llu", reinterpret_cast<void*>(memory), available );
memory = state.memory; memory = state.memory;
available = state.available; available = state.available;
} }

32
GlobalMemory.h
View File

@ -8,27 +8,27 @@ using Byte = uint8_t;
struct GlobalMemory struct GlobalMemory
{ {
struct State struct State
{ {
Byte* memory; Byte* memory;
size_t available; size_t available;
}; };
Byte* memory; Byte* memory;
size_t available; size_t available;
size_t capacity; 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. // Do not do any permanent allocations after calling this.
[[nodiscard]] State getState() const; [[nodiscard]] State getState() const;
// Call this before permanent allocations. // Call this before permanent allocations.
void restoreState(State const& state); void restoreState( State const& state );
}; };

6
MathUtil.h
View File

@ -2,8 +2,8 @@
#include <utility> #include <utility>
template <std::totally_ordered T> template < std::totally_ordered T >
T Clamp(T const val, T const minVal, T const maxVal) T Clamp( T const val, T const minVal, T const maxVal )
{ {
return std::min(maxVal, std::max(val, minVal)); return std::min( maxVal, std::max( val, minVal ) );
} }

10
MemoryUtils.h
View File

@ -1,10 +0,0 @@
#pragma once
#include <foonathan/memory/memory_arena.hpp>
#include <foonathan/memory/memory_stack.hpp>
#include <foonathan/memory/temporary_allocator.hpp>
using global_allocator_t = foonathan::memory::memory_stack<foonathan::memory::virtual_block_allocator>;
using subsystem_allocator_t = foonathan::memory::memory_stack<foonathan::memory::fixed_block_allocator<global_allocator_t>>;
using temporary_allocator_t = foonathan::memory::temporary_allocator;

500
MiscData.cpp
View File

@ -7,283 +7,283 @@
#include "RenderDevice.h" #include "RenderDevice.h"
void MiscData::init(RenderDevice const& renderDevice) void MiscData::init( RenderDevice const& renderDevice )
{ {
VkDevice const device = renderDevice.device; VkDevice const device = renderDevice.device;
{ {
size_t dataSize; size_t dataSize;
void* rawData = SDL_LoadFile("Triangle.spv", &dataSize); void* rawData = SDL_LoadFile( "Triangle.spv", &dataSize );
ASSERT(dataSize % 4 == 0); ASSERT( dataSize % 4 == 0 );
if (not rawData) if ( !rawData )
{ {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError()); SDL_LogError( SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError() );
abort(); abort();
} }
auto data = static_cast<uint32_t const*>(rawData); auto data = static_cast<uint32_t const*>(rawData);
VkShaderModuleCreateInfo const shaderModuleCreateInfo = { VkShaderModuleCreateInfo const shaderModuleCreateInfo = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.codeSize = dataSize, .codeSize = dataSize,
.pCode = data, .pCode = data,
}; };
VkShaderModule shaderModule; VkShaderModule shaderModule;
VK_CHECK(vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule)); VK_CHECK( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule) );
VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = { VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.setLayoutCount = 0, .setLayoutCount = 0,
.pSetLayouts = nullptr, .pSetLayouts = nullptr,
.pushConstantRangeCount = 0, .pushConstantRangeCount = 0,
.pPushConstantRanges = nullptr, .pPushConstantRanges = nullptr,
}; };
VK_CHECK(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout)); VK_CHECK( vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) );
std::array stages = { std::array stages = {
VkPipelineShaderStageCreateInfo{ VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.stage = VK_SHADER_STAGE_VERTEX_BIT, .stage = VK_SHADER_STAGE_VERTEX_BIT,
.module = shaderModule, .module = shaderModule,
.pName = "VertexMain", .pName = "VertexMain",
.pSpecializationInfo = nullptr, .pSpecializationInfo = nullptr,
}, },
VkPipelineShaderStageCreateInfo{ VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.stage = VK_SHADER_STAGE_FRAGMENT_BIT, .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
.module = shaderModule, .module = shaderModule,
.pName = "FragmentMain", .pName = "FragmentMain",
.pSpecializationInfo = nullptr, .pSpecializationInfo = nullptr,
} }
}; };
VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = { VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.vertexBindingDescriptionCount = 0, .vertexBindingDescriptionCount = 0,
.pVertexBindingDescriptions = nullptr, .pVertexBindingDescriptions = nullptr,
.vertexAttributeDescriptionCount = 0, .vertexAttributeDescriptionCount = 0,
.pVertexAttributeDescriptions = nullptr, .pVertexAttributeDescriptions = nullptr,
}; };
VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = { VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_FALSE, .primitiveRestartEnable = VK_FALSE,
}; };
VkPipelineTessellationStateCreateInfo constexpr tessellationState = { VkPipelineTessellationStateCreateInfo constexpr tessellationState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.patchControlPoints = 0, .patchControlPoints = 0,
}; };
VkPipelineViewportStateCreateInfo constexpr viewportState = { VkPipelineViewportStateCreateInfo constexpr viewportState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.viewportCount = 1, .viewportCount = 1,
.pViewports = nullptr, .pViewports = nullptr,
.scissorCount = 1, .scissorCount = 1,
.pScissors = nullptr, .pScissors = nullptr,
}; };
VkPipelineRasterizationStateCreateInfo constexpr rasterizationState = { VkPipelineRasterizationStateCreateInfo constexpr rasterizationState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.depthClampEnable = VK_TRUE, .depthClampEnable = VK_TRUE,
.rasterizerDiscardEnable = VK_FALSE, .rasterizerDiscardEnable = VK_FALSE,
.polygonMode = VK_POLYGON_MODE_FILL, .polygonMode = VK_POLYGON_MODE_FILL,
.cullMode = VK_CULL_MODE_NONE, .cullMode = VK_CULL_MODE_NONE,
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
.depthBiasEnable = VK_FALSE, .depthBiasEnable = VK_FALSE,
.depthBiasConstantFactor = 0.0f, .depthBiasConstantFactor = 0.0f,
.depthBiasClamp = 0.0f, .depthBiasClamp = 0.0f,
.depthBiasSlopeFactor = 0.0f, .depthBiasSlopeFactor = 0.0f,
.lineWidth = 1.0f, .lineWidth = 1.0f,
}; };
VkPipelineMultisampleStateCreateInfo constexpr multisampleState = { VkPipelineMultisampleStateCreateInfo constexpr multisampleState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
.sampleShadingEnable = VK_FALSE, .sampleShadingEnable = VK_FALSE,
.minSampleShading = 0.0f, .minSampleShading = 0.0f,
.pSampleMask = nullptr, .pSampleMask = nullptr,
.alphaToCoverageEnable = VK_FALSE, .alphaToCoverageEnable = VK_FALSE,
.alphaToOneEnable = VK_FALSE, .alphaToOneEnable = VK_FALSE,
}; };
VkPipelineDepthStencilStateCreateInfo constexpr depthStencilState = { VkPipelineDepthStencilStateCreateInfo constexpr depthStencilState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.depthTestEnable = VK_FALSE, .depthTestEnable = VK_FALSE,
.depthWriteEnable = VK_FALSE, .depthWriteEnable = VK_FALSE,
.depthCompareOp = VK_COMPARE_OP_ALWAYS, .depthCompareOp = VK_COMPARE_OP_ALWAYS,
.depthBoundsTestEnable = VK_FALSE, .depthBoundsTestEnable = VK_FALSE,
.stencilTestEnable = VK_FALSE, .stencilTestEnable = VK_FALSE,
.front = {}, .front = {},
.back = {}, .back = {},
.minDepthBounds = 0.0f, .minDepthBounds = 0.0f,
.maxDepthBounds = 1.0f, .maxDepthBounds = 1.0f,
}; };
VkPipelineColorBlendAttachmentState constexpr colorBlendAttachmentState = { VkPipelineColorBlendAttachmentState constexpr colorBlendAttachmentState = {
.blendEnable = VK_FALSE, .blendEnable = VK_FALSE,
.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA,
.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.colorBlendOp = VK_BLEND_OP_ADD, .colorBlendOp = VK_BLEND_OP_ADD,
.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE,
.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO,
.alphaBlendOp = VK_BLEND_OP_ADD, .alphaBlendOp = VK_BLEND_OP_ADD,
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT .colorWriteMask = VK_COLOR_COMPONENT_R_BIT
| VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_B_BIT
| VK_COLOR_COMPONENT_A_BIT, | VK_COLOR_COMPONENT_A_BIT,
}; };
VkPipelineColorBlendStateCreateInfo const colorBlendState = { VkPipelineColorBlendStateCreateInfo const colorBlendState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.logicOpEnable = VK_FALSE, .logicOpEnable = VK_FALSE,
.logicOp = VK_LOGIC_OP_COPY, .logicOp = VK_LOGIC_OP_COPY,
.attachmentCount = 1, .attachmentCount = 1,
.pAttachments = &colorBlendAttachmentState, .pAttachments = &colorBlendAttachmentState,
.blendConstants = {0.0f, 0.0f, 0.0f, 0.0f}, .blendConstants = { 0.0f, 0.0f, 0.0f, 0.0f },
}; };
std::array constexpr dynamicStates = { std::array constexpr dynamicStates = {
VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR VK_DYNAMIC_STATE_SCISSOR
}; };
VkPipelineDynamicStateCreateInfo const dynamicStateCreateInfo = { VkPipelineDynamicStateCreateInfo const dynamicStateCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()), .dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()),
.pDynamicStates = dynamicStates.data() .pDynamicStates = dynamicStates.data()
}; };
VkPipelineRenderingCreateInfoKHR const renderingCreateInfo = { VkPipelineRenderingCreateInfoKHR const renderingCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
.colorAttachmentCount = 1, .colorAttachmentCount = 1,
.pColorAttachmentFormats = &renderDevice.swapchainFormat, .pColorAttachmentFormats = &renderDevice.swapchainFormat,
}; };
VkGraphicsPipelineCreateInfo const graphicsPipelineCreateInfo = { VkGraphicsPipelineCreateInfo const graphicsPipelineCreateInfo = {
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.pNext = &renderingCreateInfo, .pNext = &renderingCreateInfo,
.flags = 0, .flags = 0,
.stageCount = static_cast<uint32_t>(stages.size()), .stageCount = static_cast<uint32_t>(stages.size()),
.pStages = stages.data(), .pStages = stages.data(),
.pVertexInputState = &vertexInputState, .pVertexInputState = &vertexInputState,
.pInputAssemblyState = &inputAssembly, .pInputAssemblyState = &inputAssembly,
.pTessellationState = &tessellationState, .pTessellationState = &tessellationState,
.pViewportState = &viewportState, .pViewportState = &viewportState,
.pRasterizationState = &rasterizationState, .pRasterizationState = &rasterizationState,
.pMultisampleState = &multisampleState, .pMultisampleState = &multisampleState,
.pDepthStencilState = &depthStencilState, .pDepthStencilState = &depthStencilState,
.pColorBlendState = &colorBlendState, .pColorBlendState = &colorBlendState,
.pDynamicState = &dynamicStateCreateInfo, .pDynamicState = &dynamicStateCreateInfo,
.layout = pipelineLayout, .layout = pipelineLayout,
.renderPass = nullptr, .renderPass = nullptr,
.subpass = 0, .subpass = 0,
.basePipelineHandle = nullptr, .basePipelineHandle = nullptr,
.basePipelineIndex = 0, .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 = { acquireToRenderBarrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr, .pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, .dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, .newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0, .baseMipLevel = 0,
.levelCount = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.layerCount = 1, .layerCount = 1,
} }
}; };
acquireToRenderDependency = { acquireToRenderDependency = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.pNext = nullptr, .pNext = nullptr,
.dependencyFlags = 0, .dependencyFlags = 0,
.memoryBarrierCount = 0, .memoryBarrierCount = 0,
.pMemoryBarriers = nullptr, .pMemoryBarriers = nullptr,
.bufferMemoryBarrierCount = 0, .bufferMemoryBarrierCount = 0,
.pBufferMemoryBarriers = nullptr, .pBufferMemoryBarriers = nullptr,
.imageMemoryBarrierCount = 1, .imageMemoryBarrierCount = 1,
.pImageMemoryBarriers = &acquireToRenderBarrier, .pImageMemoryBarriers = &acquireToRenderBarrier,
}; };
renderToPresentBarrier = { renderToPresentBarrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr, .pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, .dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
.dstAccessMask = VK_ACCESS_2_NONE, .dstAccessMask = VK_ACCESS_2_NONE,
.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0, .baseMipLevel = 0,
.levelCount = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.layerCount = 1, .layerCount = 1,
} }
}; };
renderToPresentDependency = { renderToPresentDependency = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.pNext = nullptr, .pNext = nullptr,
.dependencyFlags = 0, .dependencyFlags = 0,
.memoryBarrierCount = 0, .memoryBarrierCount = 0,
.pMemoryBarriers = nullptr, .pMemoryBarriers = nullptr,
.bufferMemoryBarrierCount = 0, .bufferMemoryBarrierCount = 0,
.pBufferMemoryBarriers = nullptr, .pBufferMemoryBarriers = nullptr,
.imageMemoryBarrierCount = 1, .imageMemoryBarrierCount = 1,
.pImageMemoryBarriers = &renderToPresentBarrier, .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); vkDestroyPipeline( device, trianglePipeline, nullptr );
vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyPipelineLayout( device, pipelineLayout, nullptr );
} }

16
MiscData.h
View File

@ -6,14 +6,14 @@ struct RenderDevice;
struct MiscData struct MiscData
{ {
VkPipelineLayout pipelineLayout; VkPipelineLayout pipelineLayout;
VkPipeline trianglePipeline; VkPipeline trianglePipeline;
VkImageMemoryBarrier2 acquireToRenderBarrier; VkImageMemoryBarrier2 acquireToRenderBarrier;
VkDependencyInfo acquireToRenderDependency; VkDependencyInfo acquireToRenderDependency;
VkImageMemoryBarrier2 renderToPresentBarrier; VkImageMemoryBarrier2 renderToPresentBarrier;
VkDependencyInfo renderToPresentDependency; VkDependencyInfo renderToPresentDependency;
void init(RenderDevice const& renderDevice); void init( RenderDevice const& renderDevice );
void cleanup(RenderDevice const& renderDevice); void cleanup( RenderDevice const& renderDevice );
}; };

713
RenderDevice.cpp
View File

@ -14,426 +14,455 @@
RenderDevice::~RenderDevice() RenderDevice::~RenderDevice()
{ {
ASSERT(!isInit()); ASSERT( !isInit() );
} }
// TODO: Failure Handling // 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; VkInstance instance;
// Create Instance // Create Instance
{ {
VkApplicationInfo constexpr applicationInfo = { VkApplicationInfo constexpr applicationInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pNext = nullptr, .pNext = nullptr,
.pApplicationName = "Test", .pApplicationName = "Test",
.applicationVersion = VK_MAKE_API_VERSION(0, 0, 1, 0), .applicationVersion = VK_MAKE_API_VERSION( 0, 0, 1, 0 ),
.pEngineName = "Blaze", .pEngineName = "Blaze",
.engineVersion = VK_MAKE_API_VERSION(0, 0, 1, 0), .engineVersion = VK_MAKE_API_VERSION( 0, 0, 1, 0 ),
.apiVersion = VK_API_VERSION_1_3, .apiVersion = VK_API_VERSION_1_3,
}; };
uint32_t instanceExtensionCount; uint32_t instanceExtensionCount;
char const* const* instanceExtensions = SDL_Vulkan_GetInstanceExtensions(&instanceExtensionCount); char const* const* instanceExtensions = SDL_Vulkan_GetInstanceExtensions( &instanceExtensionCount );
VkInstanceCreateInfo const instanceCreateInfo = { VkInstanceCreateInfo const instanceCreateInfo = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.pApplicationInfo = &applicationInfo, .pApplicationInfo = &applicationInfo,
.enabledLayerCount = 0, .enabledLayerCount = 0,
.ppEnabledLayerNames = nullptr, .ppEnabledLayerNames = nullptr,
.enabledExtensionCount = instanceExtensionCount, .enabledExtensionCount = instanceExtensionCount,
.ppEnabledExtensionNames = instanceExtensions, .ppEnabledExtensionNames = instanceExtensions,
}; };
VK_CHECK(vkCreateInstance(&instanceCreateInfo, nullptr, &instance)); VK_CHECK( vkCreateInstance(&instanceCreateInfo, nullptr, &instance) );
volkLoadInstance(instance); volkLoadInstance( instance );
} }
VkSurfaceKHR surface; VkSurfaceKHR surface;
// Create Surface // Create Surface
ASSERT(SDL_Vulkan_CreateSurface(createInfo.window, instance, nullptr, &surface)); ASSERT( SDL_Vulkan_CreateSurface(createInfo.window, instance, nullptr, &surface) );
VkPhysicalDevice physicalDeviceInUse = nullptr; VkPhysicalDevice physicalDeviceInUse = nullptr;
VkDevice device = nullptr; VkDevice device = nullptr;
VmaAllocator gpuAllocator = nullptr; VmaAllocator gpuAllocator = nullptr;
std::optional<uint32_t> directQueueFamilyIndex; std::optional<uint32_t> directQueueFamilyIndex;
VkQueue directQueue = nullptr; VkQueue directQueue = nullptr;
// Create Device and Queue // Create Device and Queue
{ {
auto tempAllocStart = mem->getState(); auto tempAllocStart = mem->getState();
uint32_t physicalDeviceCount; uint32_t physicalDeviceCount;
VK_CHECK(vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr)); VK_CHECK( vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr) );
SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "Found %u GPUs", physicalDeviceCount); SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "Found %u GPUs", physicalDeviceCount );
VkPhysicalDevice* physicalDevices = reinterpret_cast<VkPhysicalDevice*>(mem->allocate(sizeof(VkPhysicalDevice) * physicalDeviceCount)); VkPhysicalDevice* physicalDevices = reinterpret_cast<VkPhysicalDevice*>(mem->allocate(
VK_CHECK(vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices)); sizeof( VkPhysicalDevice ) * physicalDeviceCount ));
VK_CHECK( vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices) );
for (VkPhysicalDevice const physicalDevice : std::span{ physicalDevices, physicalDeviceCount }) for ( VkPhysicalDevice const physicalDevice : std::span{ physicalDevices, physicalDeviceCount } )
{ {
auto tempAllocQueueProperties = mem->getState(); auto tempAllocQueueProperties = mem->getState();
VkPhysicalDeviceProperties properties; VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(physicalDevice, &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", SDL_LogInfo(
VK_API_VERSION_MAJOR(properties.apiVersion), SDL_LOG_CATEGORY_GPU,
VK_API_VERSION_MINOR(properties.apiVersion), "- API Version %d.%d.%d",
VK_API_VERSION_PATCH(properties.apiVersion)); 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; constexpr static uint32_t API_PATCH_BITS = 0xFFF;
if ((properties.apiVersion & (~API_PATCH_BITS)) < VK_API_VERSION_1_3) if ( (properties.apiVersion & (~API_PATCH_BITS)) < VK_API_VERSION_1_3 )
{ {
continue; continue;
} }
if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) if ( properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU )
{ {
continue; continue;
} }
uint32_t queueFamilyCount; uint32_t queueFamilyCount;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr); vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, nullptr );
VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast<VkQueueFamilyProperties*>(mem->allocate(sizeof(VkQueueFamilyProperties) * queueFamilyCount)); VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast<VkQueueFamilyProperties*>(mem->allocate(
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilyProperties); sizeof( VkQueueFamilyProperties ) * queueFamilyCount ));
vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, queueFamilyProperties );
for (uint32_t queueFamilyIndex = 0; queueFamilyIndex != queueFamilyCount; for ( uint32_t queueFamilyIndex = 0; queueFamilyIndex != queueFamilyCount;
++queueFamilyIndex) ++queueFamilyIndex )
{ {
VkQueueFamilyProperties const& qfp = queueFamilyProperties[queueFamilyIndex]; VkQueueFamilyProperties const& qfp = queueFamilyProperties[queueFamilyIndex];
bool hasGraphicsSupport = false; bool hasGraphicsSupport = false;
bool hasComputeSupport = false; bool hasComputeSupport = false;
bool hasTransferSupport = false; bool hasTransferSupport = false;
bool hasPresentSupport = false; bool hasPresentSupport = false;
SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "- Queue [%d]", queueFamilyIndex); SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "- Queue [%d]", queueFamilyIndex );
if (qfp.queueFlags & VK_QUEUE_GRAPHICS_BIT) if ( qfp.queueFlags & VK_QUEUE_GRAPHICS_BIT )
{ {
hasGraphicsSupport = true; hasGraphicsSupport = true;
SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Graphic"); SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Graphic" );
} }
if (qfp.queueFlags & VK_QUEUE_COMPUTE_BIT) if ( qfp.queueFlags & VK_QUEUE_COMPUTE_BIT )
{ {
hasComputeSupport = true; hasComputeSupport = true;
SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Compute"); SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Compute" );
} }
if (qfp.queueFlags & VK_QUEUE_TRANSFER_BIT) if ( qfp.queueFlags & VK_QUEUE_TRANSFER_BIT )
{ {
hasTransferSupport = true; hasTransferSupport = true;
SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Transfer"); SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Transfer" );
} }
VkBool32 isSurfaceSupported; VkBool32 isSurfaceSupported;
VK_CHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported)); VK_CHECK(
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported) );
if (isSurfaceSupported) if ( isSurfaceSupported )
{ {
hasPresentSupport = true; hasPresentSupport = true;
SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Present"); SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Present" );
} }
if (hasGraphicsSupport and hasComputeSupport and hasTransferSupport and hasPresentSupport) if ( hasGraphicsSupport and hasComputeSupport and hasTransferSupport and hasPresentSupport )
{ {
physicalDeviceInUse = physicalDevice; physicalDeviceInUse = physicalDevice;
directQueueFamilyIndex = queueFamilyIndex; directQueueFamilyIndex = queueFamilyIndex;
break; break;
} }
}
} mem->restoreState( tempAllocQueueProperties );
}
mem->restoreState(tempAllocQueueProperties); ASSERT( physicalDeviceInUse );
} ASSERT( directQueueFamilyIndex.has_value() );
ASSERT(physicalDeviceInUse); float priority = 1.0f;
ASSERT(directQueueFamilyIndex.has_value()); 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; VkPhysicalDeviceVulkan13Features constexpr features13 = {
VkDeviceQueueCreateInfo queueCreateInfo = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, .pNext = nullptr,
.pNext = nullptr, .synchronization2 = true,
.flags = 0, .dynamicRendering = true,
.queueFamilyIndex = directQueueFamilyIndex.value(), };
.queueCount = 1,
.pQueuePriorities = &priority,
};
VkPhysicalDeviceVulkan13Features constexpr features13 = { VkPhysicalDeviceFeatures features = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, .depthClamp = true,
.pNext = nullptr, .samplerAnisotropy = true,
.synchronization2 = true, };
.dynamicRendering = true,
};
VkPhysicalDeviceFeatures features = { std::array enabledDeviceExtensions = {
.depthClamp = true, VK_KHR_SWAPCHAIN_EXTENSION_NAME
.samplerAnisotropy = true, };
};
std::array enabledDeviceExtensions = { VkDeviceCreateInfo const deviceCreateInfo = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
}; .pNext = &features13,
.flags = 0,
.queueCreateInfoCount = 1,
.pQueueCreateInfos = &queueCreateInfo,
.enabledLayerCount = 0,
.ppEnabledLayerNames = nullptr,
.enabledExtensionCount = static_cast<uint32_t>(enabledDeviceExtensions.size()),
.ppEnabledExtensionNames = enabledDeviceExtensions.data(),
.pEnabledFeatures = &features,
};
VkDeviceCreateInfo const deviceCreateInfo = { VK_CHECK( vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device) );
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, volkLoadDevice( device );
.pNext = &features13,
.flags = 0,
.queueCreateInfoCount = 1,
.pQueueCreateInfos = &queueCreateInfo,
.enabledLayerCount = 0,
.ppEnabledLayerNames = nullptr,
.enabledExtensionCount = static_cast<uint32_t>(enabledDeviceExtensions.size()),
.ppEnabledExtensionNames = enabledDeviceExtensions.data(),
.pEnabledFeatures = &features,
};
VK_CHECK(vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device)); VmaAllocatorCreateInfo allocatorCreateInfo = {
volkLoadDevice(device); .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 = { VmaVulkanFunctions vkFunctions;
.flags = 0, VK_CHECK( vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions) );
.physicalDevice = physicalDeviceInUse, allocatorCreateInfo.pVulkanFunctions = &vkFunctions;
.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( vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator) );
VK_CHECK(vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions));
allocatorCreateInfo.pVulkanFunctions = &vkFunctions;
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 VkSurfaceCapabilitiesKHR capabilities;
VkExtent2D swapchainExtent = { createInfo.width, createInfo.height }; VK_CHECK( vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities) );
VkFormat swapchainFormat = VK_FORMAT_UNDEFINED;
VkSwapchainKHR swapchain;
VkImage* swapchainImages;
VkImageView* swapchainViews;
uint32_t swapchainImageCount;
{
auto tempAllocStart = mem->getState();
VkSurfaceCapabilitiesKHR capabilities; // Image Count Calculation
VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities)); swapchainImageCount = 3;
if ( capabilities.maxImageCount > 0 )
{
swapchainImageCount = std::min( swapchainImageCount, capabilities.maxImageCount );
}
swapchainImageCount = std::max( swapchainImageCount, capabilities.minImageCount + 1 );
// Image Count Calculation // Image Size calculation
swapchainImageCount = 3; {
if (capabilities.maxImageCount > 0) auto [minWidth, minHeight] = capabilities.minImageExtent;
{ auto [maxWidth, maxHeight] = capabilities.maxImageExtent;
swapchainImageCount = std::min(swapchainImageCount, capabilities.maxImageCount); swapchainExtent.width = Clamp( swapchainExtent.width, minWidth, maxWidth );
} swapchainExtent.height = Clamp( swapchainExtent.height, minHeight, maxHeight );
swapchainImageCount = std::max(swapchainImageCount, capabilities.minImageCount + 1); }
// Image Size calculation uint32_t surfaceFormatCount;
{ vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, nullptr );
auto [minWidth, minHeight] = capabilities.minImageExtent; VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(
auto [maxWidth, maxHeight] = capabilities.maxImageExtent; sizeof( VkSurfaceFormatKHR* ) * surfaceFormatCount ));
swapchainExtent.width = Clamp(swapchainExtent.width, minWidth, maxWidth); vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats );
swapchainExtent.height = Clamp(swapchainExtent.height, minHeight, maxHeight);
}
uint32_t surfaceFormatCount; VkSurfaceFormatKHR format = {
vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, nullptr); .format = VK_FORMAT_UNDEFINED,
VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(sizeof(VkSurfaceFormatKHR*) * surfaceFormatCount)); .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats); };
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 = { uint32_t presentModeCount;
.format = VK_FORMAT_UNDEFINED, vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, nullptr );
.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(
}; sizeof( VkPresentModeKHR* ) * presentModeCount ));
for (auto& surfaceFormat : std::span{ surfaceFormats, surfaceFormatCount }) vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, presentModes );
{
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; VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, nullptr); for ( VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount } )
VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(sizeof(VkPresentModeKHR*) * presentModeCount)); {
vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, presentModes); if ( presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR )
{
presentMode = presentModeIter;
break;
}
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; if ( presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR )
for (VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount }) {
{ presentMode = presentModeIter;
if (presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR) }
{ }
presentMode = presentModeIter;
break;
}
if (presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR) mem->restoreState( tempAllocStart );
{
presentMode = presentModeIter;
}
}
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 = { VK_CHECK( vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr, &swapchain) );
.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)); swapchainImageCount = 0;
vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, nullptr );
swapchainImages = reinterpret_cast<VkImage*>(mem->allocate( sizeof( VkImage ) * swapchainImageCount ));
vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, swapchainImages );
swapchainImageCount = 0; swapchainViews = reinterpret_cast<VkImageView*>(mem->allocate( sizeof( VkImageView ) * swapchainImageCount ));
vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, nullptr); for ( uint32_t i = 0; i != swapchainImageCount; ++i )
swapchainImages = reinterpret_cast<VkImage*>(mem->allocate(sizeof(VkImage) * swapchainImageCount)); {
vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, swapchainImages); 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<VkImageView*>(mem->allocate(sizeof(VkImageView) * swapchainImageCount)); VK_CHECK( vkCreateImageView(device, &viewCreateInfo, nullptr, &swapchainViews[i]) );
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])); // Init frames.
}
}
// Init frames. Frame* frames = reinterpret_cast<Frame*>(mem->allocate( sizeof( Frame ) * swapchainImageCount ));
for ( uint32_t i = 0; i != swapchainImageCount; ++i )
{
new( frames + i ) Frame( device, directQueueFamilyIndex.value() );
}
Frame* frames = reinterpret_cast<Frame*>(mem->allocate(sizeof(Frame) * swapchainImageCount)); Byte* allocation = mem->allocate( sizeof( RenderDevice ), alignof( RenderDevice ) );
for (uint32_t i = 0; i != swapchainImageCount; ++i) return new( allocation ) RenderDevice{
{ instance,
new (frames + i) Frame(device, directQueueFamilyIndex.value()); surface,
} physicalDeviceInUse,
device,
Byte* allocation = mem->allocate(sizeof(RenderDevice), alignof(RenderDevice)); gpuAllocator,
return new (allocation) RenderDevice{ directQueue,
instance, surface, physicalDeviceInUse, directQueueFamilyIndex.value(),
device, gpuAllocator, directQueue, directQueueFamilyIndex.value(), swapchainFormat,
swapchainFormat, swapchainExtent, swapchain, swapchainImages, swapchainViews, frames, swapchainImageCount, swapchainExtent,
}; swapchain,
swapchainImages,
swapchainViews,
frames,
swapchainImageCount,
};
} }
inline bool RenderDevice::isInit() const inline bool RenderDevice::isInit() const
{ {
return instance and device; return instance and device;
} }
void RenderDevice::cleanup() void RenderDevice::destroy()
{ {
if (not isInit()) if ( not isInit() ) return;
return;
for (Frame& frame : std::span{ frames, swapchainImageCount }) for ( Frame& frame : std::span{ frames, swapchainImageCount } )
{ {
frame.cleanup(*this); frame.destroy( *this );
} }
for (auto const& view : std::span{ swapchainViews, swapchainImageCount }) for ( auto const& view : std::span{ swapchainViews, swapchainImageCount } )
{ {
vkDestroyImageView(device, view, nullptr); 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 void RenderDevice::waitIdle() const
{ {
VK_CHECK(vkDeviceWaitIdle(device)); VK_CHECK( vkDeviceWaitIdle(device) );
} }
uint32_t RenderDevice::getNumFrames() const uint32_t RenderDevice::getNumFrames() const
{ {
return swapchainImageCount; return swapchainImageCount;
} }
RenderDevice::RenderDevice(VkInstance const instance, VkSurfaceKHR const surface, VkPhysicalDevice const physicalDeviceInUse, RenderDevice::RenderDevice(
VkDevice const device, VmaAllocator gpuAllocator, VkQueue const directQueue, uint32_t const directQueueFamilyIndex, VkInstance const instance,
VkFormat const swapchainFormat, VkExtent2D const swapchainExtent, VkSwapchainKHR const swapchain, VkImage* swapchainImages, VkSurfaceKHR const surface,
VkImageView* swapchainViews, Frame* frames, uint32_t const swapchainImageCount) VkPhysicalDevice const physicalDeviceInUse,
: instance{ instance } VkDevice const device,
, surface{ surface } VmaAllocator gpuAllocator,
, physicalDeviceInUse{ physicalDeviceInUse } VkQueue const directQueue,
, device{ device } uint32_t const directQueueFamilyIndex,
, gpuAllocator{ gpuAllocator } VkFormat const swapchainFormat,
, directQueue{ directQueue } VkExtent2D const swapchainExtent,
, directQueueFamilyIndex{ directQueueFamilyIndex } VkSwapchainKHR const swapchain,
, swapchainFormat{ swapchainFormat } VkImage* swapchainImages,
, swapchainExtent{ swapchainExtent } VkImageView* swapchainViews,
, swapchain{ swapchain } Frame* frames,
, swapchainImages{ swapchainImages } uint32_t const swapchainImageCount )
, swapchainViews{ swapchainViews } : instance{ instance }
, frames{ frames } , surface{ surface }
, swapchainImageCount{ swapchainImageCount } , physicalDeviceInUse{ physicalDeviceInUse }
{ , device{ device }
} , gpuAllocator{ gpuAllocator }
, directQueue{ directQueue }
, directQueueFamilyIndex{ directQueueFamilyIndex }
, swapchainFormat{ swapchainFormat }
, swapchainExtent{ swapchainExtent }
, swapchain{ swapchain }
, swapchainImages{ swapchainImages }
, swapchainViews{ swapchainViews }
, frames{ frames }
, swapchainImageCount{ swapchainImageCount } {}

96
RenderDevice.h
View File

@ -18,63 +18,63 @@ struct Frame;
/// TODO: Fail elegantly. /// TODO: Fail elegantly.
struct RenderDevice struct RenderDevice
{ {
struct CreateInfo struct CreateInfo
{ {
SDL_Window* window = nullptr; SDL_Window* window = nullptr;
uint32_t width = 640; uint32_t width = 640;
uint32_t height = 480; uint32_t height = 480;
}; };
VkInstance instance; VkInstance instance;
VkSurfaceKHR surface; VkSurfaceKHR surface;
VkPhysicalDevice physicalDeviceInUse; VkPhysicalDevice physicalDeviceInUse;
VkDevice device; VkDevice device;
VmaAllocator gpuAllocator; VmaAllocator gpuAllocator;
VkQueue directQueue; VkQueue directQueue;
uint32_t directQueueFamilyIndex; uint32_t directQueueFamilyIndex;
VkFormat swapchainFormat; VkFormat swapchainFormat;
VkExtent2D swapchainExtent; VkExtent2D swapchainExtent;
VkSwapchainKHR swapchain; VkSwapchainKHR swapchain;
VkImage* swapchainImages; VkImage* swapchainImages;
VkImageView* swapchainViews; VkImageView* swapchainViews;
Frame* frames; Frame* frames;
uint32_t swapchainImageCount; uint32_t swapchainImageCount;
uint32_t frameIndex = 0; uint32_t frameIndex = 0;
[[nodiscard]] bool isInit() const; [[nodiscard]] bool isInit() const;
void cleanup(); void destroy();
void waitIdle() const; void waitIdle() const;
[[nodiscard]] uint32_t getNumFrames() const; [[nodiscard]] uint32_t getNumFrames() const;
RenderDevice( RenderDevice(
VkInstance instance, VkInstance instance,
VkSurfaceKHR surface, VkSurfaceKHR surface,
VkPhysicalDevice physicalDeviceInUse, VkPhysicalDevice physicalDeviceInUse,
VkDevice device, VkDevice device,
VmaAllocator gpuAllocator, VmaAllocator gpuAllocator,
VkQueue directQueue, VkQueue directQueue,
uint32_t directQueueFamilyIndex, uint32_t directQueueFamilyIndex,
// TODO: Pack? // TODO: Pack?
VkFormat swapchainFormat, VkFormat swapchainFormat,
VkExtent2D swapchainExtent, VkExtent2D swapchainExtent,
VkSwapchainKHR swapchain, VkSwapchainKHR swapchain,
VkImage* swapchainImages, VkImage* swapchainImages,
VkImageView* swapchainViews, VkImageView* swapchainViews,
Frame* frames, Frame* frames,
uint32_t swapchainImageCount uint32_t swapchainImageCount
); );
RenderDevice(RenderDevice const&) = delete; RenderDevice( RenderDevice const& ) = delete;
RenderDevice& operator=(RenderDevice const&) = delete; RenderDevice& operator=( RenderDevice const& ) = delete;
RenderDevice(RenderDevice&&) noexcept = delete; RenderDevice( RenderDevice&& ) noexcept = delete;
RenderDevice& operator=(RenderDevice&&) noexcept = delete; RenderDevice& operator=( RenderDevice&& ) noexcept = delete;
~RenderDevice(); ~RenderDevice();
}; };
RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo); RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo );