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

Compare commits

base: kidrigger:fd9ceae67d9d327d1cc3f565c08cb986cf0a095f
Branches Tags
kidrigger:canon
..
compare: kidrigger:e7d74e6b0f656ce962dc6ceae99c47d726e9d629
Branches Tags
kidrigger:canon

No commits in common. "fd9ceae67d9d327d1cc3f565c08cb986cf0a095f" and "e7d74e6b0f656ce962dc6ceae99c47d726e9d629" have entirely different histories.
fd9ceae67d ... e7d74e6b0f

21 changed files with 957 additions and 1295 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -613,4 +613,3 @@ $RECYCLE.BIN/
# Windows shortcuts # Windows shortcuts
*.lnk *.lnk
*.spv

75
AppState.cpp
View File

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

28
AppState.h
View File

@ -2,31 +2,29 @@
#include <memory> #include <memory>
struct SDL_Window;
struct GlobalMemory; struct GlobalMemory;
struct SDL_Window;
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]] [[nodiscard]] bool isInit() const;
bool isInit() const; void cleanup();
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);

301
Blaze.cpp
View File

@ -10,7 +10,6 @@
#define SDL_MAIN_USE_CALLBACKS 1 #define SDL_MAIN_USE_CALLBACKS 1
#include <memory> #include <memory>
#include <glm/ext/matrix_transform.hpp>
#include <SDL3/SDL.h> #include <SDL3/SDL.h>
#include <SDL3/SDL_main.h> #include <SDL3/SDL_main.h>
#include <SDL3/SDL_filesystem.h> #include <SDL3/SDL_filesystem.h>
@ -24,223 +23,187 @@
#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 ) return SDL_APP_FAILURE; if (!*pAppState)
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;
} }
char g_buf[1000]; 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( VK_CHECK(vkWaitForFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse, VK_TRUE, std::numeric_limits<uint32_t>::max()));
vkWaitForFences(renderDevice.device, // All resources of frame 'frameIndex' are free.
1,
&currentFrame.frameReadyToReuse,
VK_TRUE,
std::numeric_limits<uint32_t>::max()) );
// All resources of frame 'frameIndex' are free.
uint64_t const previousCounter = misc.previousCounter; uint32_t currentImageIndex;
uint64_t const currentCounter = SDL_GetPerformanceCounter(); VK_CHECK(vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits<uint32_t>::max(), currentFrame.imageAcquiredSemaphore, nullptr, &currentImageIndex));
uint64_t const deltaCount = currentCounter - previousCounter;
uint64_t const perfFreq = SDL_GetPerformanceFrequency();
double const deltaTime = static_cast<double>(deltaCount) / static_cast<double>(perfFreq);
misc.previousCounter = currentCounter;
double deltaTimeMs = deltaTime * 1000.0; VK_CHECK(vkResetFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse));
double fps = 1.0 / deltaTime; VK_CHECK(vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0));
auto _ = sprintf_s<1000>( g_buf, "%.2f fps %.5fms %llu -> %llu", fps, deltaTimeMs, previousCounter, currentCounter );
SDL_SetWindowTitle( appState.window, g_buf );
misc.cameraData.modelMatrix = glm::rotate( misc.acquireToRenderBarrier.image = renderDevice.swapchainImages[currentImageIndex];
misc.cameraData.modelMatrix, misc.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex];
glm::radians( 60.0f ) * static_cast<float>(deltaTime),
glm::vec3{ 0.0f, 1.0f, 0.0f } );
memcpy( misc.cameraUniformBufferPtr, &misc.cameraData, sizeof misc.cameraData );
uint32_t currentImageIndex; VkCommandBuffer cmd = currentFrame.commandBuffer;
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) ); VkCommandBufferBeginInfo constexpr beginInfo = {
VK_CHECK( vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0) ); .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = nullptr,
.flags = 0,
.pInheritanceInfo = nullptr,
};
misc.acquireToRenderBarrier.image = renderDevice.swapchainImages[currentImageIndex]; VkClearColorValue constexpr static BLACK_CLEAR = {
misc.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex]; .float32 = { 0.0f, 0.0f, 0.0f, 1.0f },
};
VkCommandBuffer cmd = currentFrame.commandBuffer; 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},
};
VkCommandBufferBeginInfo constexpr beginInfo = { VkRenderingInfo renderingInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.pInheritanceInfo = nullptr, .renderArea = {.offset = {0,0}, .extent = renderDevice.swapchainExtent},
}; .layerCount = 1,
.viewMask = 0,
.colorAttachmentCount = 1,
.pColorAttachments = &attachmentInfo,
.pDepthAttachment = nullptr,
.pStencilAttachment = nullptr,
};
VkClearColorValue constexpr static BLACK_CLEAR = { vkCmdPipelineBarrier2(cmd, &misc.acquireToRenderDependency);
.float32 = { 0.0f, 0.0f, 0.0f, 1.0f }, vkCmdBeginRendering(cmd, &renderingInfo);
}; {
VkViewport viewport = {
.x = 0,
.y = static_cast<float>(renderDevice.swapchainExtent.height),
.width = static_cast<float>(renderDevice.swapchainExtent.width),
.height = -static_cast<float>(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);
VK_CHECK( vkBeginCommandBuffer(cmd, &beginInfo) ); // Render Something?
{ vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline);
VkRenderingAttachmentInfo const attachmentInfo = { vkCmdDraw(cmd, 3, 1, 0, 0);
.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, vkCmdEndRendering(cmd);
.pNext = nullptr, vkCmdPipelineBarrier2(cmd, &misc.renderToPresentDependency);
.flags = 0, }
.renderArea = { .offset = { 0, 0 }, .extent = renderDevice.swapchainExtent }, VK_CHECK(vkEndCommandBuffer(cmd));
.layerCount = 1,
.viewMask = 0,
.colorAttachmentCount = 1,
.pColorAttachments = &attachmentInfo,
.pDepthAttachment = nullptr,
.pStencilAttachment = nullptr,
};
vkCmdPipelineBarrier2( cmd, &misc.acquireToRenderDependency ); VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
vkCmdBeginRendering( cmd, &renderingInfo ); VkSubmitInfo const submitInfo = {
{ .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
VkViewport viewport = { .pNext = nullptr,
.x = 0, .waitSemaphoreCount = 1,
.y = static_cast<float>(renderDevice.swapchainExtent.height), .pWaitSemaphores = &currentFrame.imageAcquiredSemaphore,
.width = static_cast<float>(renderDevice.swapchainExtent.width), .pWaitDstStageMask = &stageMask,
.height = -static_cast<float>(renderDevice.swapchainExtent.height), .commandBufferCount = 1,
.minDepth = 0.0f, .pCommandBuffers = &cmd,
.maxDepth = 1.0f, .signalSemaphoreCount = 1,
}; .pSignalSemaphores = &currentFrame.renderFinishedSemaphore,
vkCmdSetViewport( cmd, 0, 1, &viewport ); };
VkRect2D scissor = { VK_CHECK(vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse));
.offset = { 0, 0 },
.extent = renderDevice.swapchainExtent,
};
vkCmdSetScissor( cmd, 0, 1, &scissor );
// Render Something? VkPresentInfoKHR const presentInfo = {
vkCmdBindPipeline( cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.meshPipeline ); .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
VkDeviceSize constexpr offset = 0; .pNext = nullptr,
vkCmdBindVertexBuffers( cmd, 0, 1, &misc.vertexBuffer, &offset ); .waitSemaphoreCount = 1,
vkCmdBindDescriptorSets( .pWaitSemaphores = &currentFrame.renderFinishedSemaphore,
cmd, .swapchainCount = 1,
VK_PIPELINE_BIND_POINT_GRAPHICS, .pSwapchains = &renderDevice.swapchain,
misc.pipelineLayout, .pImageIndices = &currentImageIndex,
0, .pResults = nullptr,
1, };
&misc.descriptorSet,
0,
nullptr );
vkCmdDraw( cmd, static_cast<uint32_t>(misc.vertices.size()), 1, 0, 0 );
}
vkCmdEndRendering( cmd );
vkCmdPipelineBarrier2( cmd, &misc.renderToPresentDependency );
}
VK_CHECK( vkEndCommandBuffer(cmd) );
VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; VK_CHECK(vkQueuePresentKHR(renderDevice.directQueue, &presentInfo));
VkSubmitInfo const submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = nullptr,
.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) );
VkPresentInfoKHR const presentInfo = { renderDevice.frameIndex = (renderDevice.frameIndex + 1) % NUM_FRAMES;
.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) ); return SDL_APP_CONTINUE;
renderDevice.frameIndex = (renderDevice.frameIndex + 1) % NUM_FRAMES;
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->destroy(); appState->cleanup();
Blaze::Global::g_Memory.destroy(); Blaze::Global::g_Memory.destroy();
} }

3
Blaze.vcxproj
View File

@ -163,7 +163,7 @@
</SubType> </SubType>
</None> </None>
<None Include="README.md" /> <None Include="README.md" />
<CustomBuild Include="Mesh.slang"> <CustomBuild Include="Triangle.slang">
<FileType>Document</FileType> <FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">slangc %(FullPath) -profile sm_6_6 -target spirv -o %(Filename).spv</Command> <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">slangc %(FullPath) -profile sm_6_6 -target spirv -o %(Filename).spv</Command>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(Filename).spv</Outputs> <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(Filename).spv</Outputs>
@ -183,6 +183,7 @@
<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" />

5
Blaze.vcxproj.filters
View File

@ -58,7 +58,7 @@
</None> </None>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<CustomBuild Include="Mesh.slang"> <CustomBuild Include="Triangle.slang">
<Filter>Shader Files</Filter> <Filter>Shader Files</Filter>
</CustomBuild> </CustomBuild>
</ItemGroup> </ItemGroup>
@ -75,6 +75,9 @@
<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::destroy( RenderDevice const& renderDevice ) void Frame::cleanup(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,17 +7,18 @@ 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 destroy( RenderDevice const& renderDevice ); void cleanup(RenderDevice const& renderDevice);
~Frame(); ~Frame();
}; };

80
GlobalMemory.cpp
View File

@ -2,70 +2,64 @@
#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_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "ALLOC: %p -> %p (%llu) (avail: %llu)", reinterpret_cast<void*>(retVal), reinterpret_cast<void*>(memory), size, available);
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;
} }

34
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 size ); void init(size_t const size);
void destroy(); void destroy();
Byte* allocate( size_t size ); Byte* allocate(size_t const size);
Byte* allocate( size_t size, size_t alignment ); Byte* allocate(size_t const size, size_t const 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);
}; };

2
MacroUtils.h
View File

@ -26,4 +26,4 @@ do { \
} \ } \
} while(false) } while(false)
#define Take(OBJ) std::exchange(OBJ, {}) #define Take(OBJ) std::exchange(OBJ, {})

8
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 Normal file
View File

@ -0,0 +1,10 @@
#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;

727
MiscData.cpp
View File

@ -6,511 +6,284 @@
#include "MacroUtils.h" #include "MacroUtils.h"
#include "RenderDevice.h" #include "RenderDevice.h"
#include <glm/gtc/matrix_transform.hpp>
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;
void* rawData = SDL_LoadFile("Triangle.spv", &dataSize);
ASSERT(dataSize % 4 == 0);
previousCounter = 0; if (not rawData)
{
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError());
abort();
}
// Pipeline Creation auto data = static_cast<uint32_t const*>(rawData);
{
size_t dataSize;
void* rawData = SDL_LoadFile( "Mesh.spv", &dataSize );
ASSERT( dataSize % 4 == 0 );
if ( !rawData ) VkShaderModuleCreateInfo const shaderModuleCreateInfo = {
{ .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
SDL_LogError( SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError() ); .pNext = nullptr,
abort(); .flags = 0,
} .codeSize = dataSize,
.pCode = data,
};
auto data = static_cast<uint32_t const*>(rawData); VkShaderModule shaderModule;
VK_CHECK(vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule));
VkShaderModuleCreateInfo const shaderModuleCreateInfo = { VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.codeSize = dataSize, .setLayoutCount = 0,
.pCode = data, .pSetLayouts = nullptr,
}; .pushConstantRangeCount = 0,
.pPushConstantRanges = nullptr,
};
VK_CHECK(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));
VkShaderModule shaderModule; std::array stages = {
VK_CHECK( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule) ); 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,
}
};
VkDescriptorSetLayoutBinding constexpr descriptorSetLayoutBinding = { VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = {
.binding = 0, .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .pNext = nullptr,
.descriptorCount = 1, .flags = 0,
.stageFlags = VK_SHADER_STAGE_VERTEX_BIT, .vertexBindingDescriptionCount = 0,
.pImmutableSamplers = nullptr, .pVertexBindingDescriptions = nullptr,
}; .vertexAttributeDescriptionCount = 0,
.pVertexAttributeDescriptions = nullptr,
};
VkDescriptorSetLayoutCreateInfo const descriptorSetLayoutCreateInfo = { VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.bindingCount = 1, .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.pBindings = &descriptorSetLayoutBinding, .primitiveRestartEnable = VK_FALSE,
}; };
VK_CHECK( vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCreateInfo, nullptr, &descriptorSetLayout) );
VkPipelineLayoutCreateInfo const pipelineLayoutCreateInfo = { VkPipelineTessellationStateCreateInfo constexpr tessellationState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.setLayoutCount = 1, .patchControlPoints = 0,
.pSetLayouts = &descriptorSetLayout, };
.pushConstantRangeCount = 0,
.pPushConstantRanges = nullptr,
};
VK_CHECK( vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) );
std::array stages = { VkPipelineViewportStateCreateInfo constexpr viewportState = {
VkPipelineShaderStageCreateInfo{ .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .pNext = nullptr,
.pNext = nullptr, .flags = 0,
.flags = 0, .viewportCount = 1,
.stage = VK_SHADER_STAGE_VERTEX_BIT, .pViewports = nullptr,
.module = shaderModule, .scissorCount = 1,
.pName = "VertexMain", .pScissors = nullptr,
.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,
}
};
VkVertexInputBindingDescription constexpr bindingDescription = { VkPipelineRasterizationStateCreateInfo constexpr rasterizationState = {
.binding = 0, .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.stride = sizeof( Vertex ), .pNext = nullptr,
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX, .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,
};
std::array attributeDescriptions = { VkPipelineMultisampleStateCreateInfo constexpr multisampleState = {
VkVertexInputAttributeDescription{ .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.location = 0, .pNext = nullptr,
.binding = 0, .flags = 0,
.format = VK_FORMAT_R32G32B32A32_SFLOAT, .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
.offset = offsetof( Vertex, position ), .sampleShadingEnable = VK_FALSE,
}, .minSampleShading = 0.0f,
VkVertexInputAttributeDescription{ .pSampleMask = nullptr,
.location = 1, .alphaToCoverageEnable = VK_FALSE,
.binding = 0, .alphaToOneEnable = VK_FALSE,
.format = VK_FORMAT_R32G32B32A32_SFLOAT, };
.offset = offsetof( Vertex, color ),
},
};
VkPipelineVertexInputStateCreateInfo const vertexInputState = { VkPipelineDepthStencilStateCreateInfo constexpr depthStencilState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.vertexBindingDescriptionCount = 1, .depthTestEnable = VK_FALSE,
.pVertexBindingDescriptions = &bindingDescription, .depthWriteEnable = VK_FALSE,
.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size()), .depthCompareOp = VK_COMPARE_OP_ALWAYS,
.pVertexAttributeDescriptions = attributeDescriptions.data(), .depthBoundsTestEnable = VK_FALSE,
}; .stencilTestEnable = VK_FALSE,
.front = {},
.back = {},
.minDepthBounds = 0.0f,
.maxDepthBounds = 1.0f,
};
VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = { VkPipelineColorBlendAttachmentState constexpr colorBlendAttachmentState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, .blendEnable = VK_FALSE,
.pNext = nullptr, .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA,
.flags = 0, .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, .colorBlendOp = VK_BLEND_OP_ADD,
.primitiveRestartEnable = VK_FALSE, .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,
};
VkPipelineTessellationStateCreateInfo constexpr tessellationState = { VkPipelineColorBlendStateCreateInfo const colorBlendState = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.patchControlPoints = 0, .logicOpEnable = VK_FALSE,
}; .logicOp = VK_LOGIC_OP_COPY,
.attachmentCount = 1,
.pAttachments = &colorBlendAttachmentState,
.blendConstants = {0.0f, 0.0f, 0.0f, 0.0f},
};
VkPipelineViewportStateCreateInfo constexpr viewportState = { std::array constexpr dynamicStates = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, VK_DYNAMIC_STATE_VIEWPORT,
.pNext = nullptr, VK_DYNAMIC_STATE_SCISSOR
.flags = 0, };
.viewportCount = 1,
.pViewports = nullptr,
.scissorCount = 1,
.pScissors = nullptr,
};
VkPipelineRasterizationStateCreateInfo constexpr rasterizationState = { VkPipelineDynamicStateCreateInfo const dynamicStateCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.depthClampEnable = VK_TRUE, .dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()),
.rasterizerDiscardEnable = VK_FALSE, .pDynamicStates = dynamicStates.data()
.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 = { VkPipelineRenderingCreateInfoKHR const renderingCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
.pNext = nullptr, .colorAttachmentCount = 1,
.flags = 0, .pColorAttachmentFormats = &renderDevice.swapchainFormat,
.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, };
.sampleShadingEnable = VK_FALSE,
.minSampleShading = 0.0f,
.pSampleMask = nullptr,
.alphaToCoverageEnable = VK_FALSE,
.alphaToOneEnable = VK_FALSE,
};
VkPipelineDepthStencilStateCreateInfo constexpr depthStencilState = { VkGraphicsPipelineCreateInfo const graphicsPipelineCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.pNext = nullptr, .pNext = &renderingCreateInfo,
.flags = 0, .flags = 0,
.depthTestEnable = VK_FALSE, .stageCount = static_cast<uint32_t>(stages.size()),
.depthWriteEnable = VK_FALSE, .pStages = stages.data(),
.depthCompareOp = VK_COMPARE_OP_ALWAYS, .pVertexInputState = &vertexInputState,
.depthBoundsTestEnable = VK_FALSE, .pInputAssemblyState = &inputAssembly,
.stencilTestEnable = VK_FALSE, .pTessellationState = &tessellationState,
.front = {}, .pViewportState = &viewportState,
.back = {}, .pRasterizationState = &rasterizationState,
.minDepthBounds = 0.0f, .pMultisampleState = &multisampleState,
.maxDepthBounds = 1.0f, .pDepthStencilState = &depthStencilState,
}; .pColorBlendState = &colorBlendState,
.pDynamicState = &dynamicStateCreateInfo,
.layout = pipelineLayout,
.renderPass = nullptr,
.subpass = 0,
.basePipelineHandle = nullptr,
.basePipelineIndex = 0,
};
VkPipelineColorBlendAttachmentState constexpr colorBlendAttachmentState = { VK_CHECK(vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &trianglePipeline));
.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 = { vkDestroyShaderModule(device, shaderModule, nullptr);
.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 = { SDL_free(rawData);
VK_DYNAMIC_STATE_VIEWPORT, }
VK_DYNAMIC_STATE_SCISSOR
};
VkPipelineDynamicStateCreateInfo const dynamicStateCreateInfo = { acquireToRenderBarrier = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()), .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
.pDynamicStates = dynamicStates.data() .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,
};
VkPipelineRenderingCreateInfoKHR const renderingCreateInfo = { renderToPresentBarrier = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.colorAttachmentCount = 1, .pNext = nullptr,
.pColorAttachmentFormats = &renderDevice.swapchainFormat, .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,
VkGraphicsPipelineCreateInfo const graphicsPipelineCreateInfo = { .dstAccessMask = VK_ACCESS_2_NONE,
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.pNext = &renderingCreateInfo, .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.flags = 0, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.stageCount = static_cast<uint32_t>(stages.size()), .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.pStages = stages.data(), .subresourceRange = {
.pVertexInputState = &vertexInputState, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.pInputAssemblyState = &inputAssembly, .baseMipLevel = 0,
.pTessellationState = &tessellationState, .levelCount = 1,
.pViewportState = &viewportState, .baseArrayLayer = 0,
.pRasterizationState = &rasterizationState, .layerCount = 1,
.pMultisampleState = &multisampleState, }
.pDepthStencilState = &depthStencilState, };
.pColorBlendState = &colorBlendState, renderToPresentDependency = {
.pDynamicState = &dynamicStateCreateInfo, .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.layout = pipelineLayout, .pNext = nullptr,
.renderPass = nullptr, .dependencyFlags = 0,
.subpass = 0, .memoryBarrierCount = 0,
.basePipelineHandle = nullptr, .pMemoryBarriers = nullptr,
.basePipelineIndex = 0, .bufferMemoryBarrierCount = 0,
}; .pBufferMemoryBarriers = nullptr,
.imageMemoryBarrierCount = 1,
VK_CHECK( vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &meshPipeline) ); .pImageMemoryBarriers = &renderToPresentBarrier,
};
vkDestroyShaderModule( device, shaderModule, nullptr );
SDL_free( rawData );
}
// Vertex Buffer Creation
{
vertexBufferSize = sizeof vertices[0] * vertices.size();
// TL----TR
// | \ |
// | \ |
// | \ |
// BL----BR
//
// BL -> BR -> TL
// TL -> BR -> TR
vertices = std::array{
// Bottom Left
Vertex{
.position = { -1.0f, -1.0f, 0.0f, 1.0f },
.color = { 0.0f, 0.0f, 1.0f, 1.0f },
},
// Bottom Right
Vertex{
.position = { 1.0f, -1.0f, 0.0f, 1.0f },
.color = { 1.0f, 0.0f, 0.0f, 1.0f },
},
// Top Left
Vertex{
.position = { -1.0f, 1.0f, 0.0f, 1.0f },
.color = { 0.0f, 1.0f, 0.0f, 1.0f },
},
// Top Right
Vertex{
.position = { 1.0f, 1.0f, 0.0f, 1.0f },
.color = { 1.0f, 1.0f, 0.0f, 1.0f },
}
};
VkBufferCreateInfo const bufferCreateInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = vertexBufferSize,
.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.queueFamilyIndexCount = 0,
.pQueueFamilyIndices = nullptr,
};
VmaAllocationCreateInfo constexpr allocationCreateInfo = {
.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT |
VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
.usage = VMA_MEMORY_USAGE_AUTO,
.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
.preferredFlags = 0,
.memoryTypeBits = 0,
.pool = nullptr,
.pUserData = nullptr,
.priority = 1.0f,
};
VmaAllocationInfo allocationInfo;
VK_CHECK(
vmaCreateBuffer(
renderDevice.gpuAllocator,
&bufferCreateInfo,
&allocationCreateInfo,
&vertexBuffer,
&vertexBufferAllocation,
&allocationInfo) );
if ( allocationInfo.pMappedData )
{
memcpy( allocationInfo.pMappedData, vertices.data(), vertices.size() * sizeof vertices[0] );
}
}
// Camera
{
cameraPosition = glm::vec3{ 0.0f, 0.0f, -5.0f };
cameraTarget = glm::vec3{ 0.0f, 0.0f, 0.0f };
cameraData.modelMatrix = glm::mat4{ 1.0f };
cameraData.viewMatrix = glm::lookAt( cameraPosition, cameraTarget, glm::vec3{ 0.0f, 1.0f, 0.0f } );
cameraData.projectionMatrix = glm::perspective( glm::radians( 70.0f ), 16.0f / 9.0f, 0.1f, 1000.0f );
cameraUniformBufferSize = sizeof( CameraData );
VkBufferCreateInfo const bufferCreateInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = cameraUniformBufferSize,
.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.queueFamilyIndexCount = 0,
.pQueueFamilyIndices = nullptr,
};
VmaAllocationCreateInfo constexpr allocationCreateInfo = {
.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT |
VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
.usage = VMA_MEMORY_USAGE_AUTO,
.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
.preferredFlags = 0,
.memoryTypeBits = 0,
.pool = nullptr,
.pUserData = nullptr,
.priority = 1.0f,
};
VmaAllocationInfo allocationInfo;
VK_CHECK(
vmaCreateBuffer(
renderDevice.gpuAllocator,
&bufferCreateInfo,
&allocationCreateInfo,
&cameraUniformBuffer,
&cameraUniformBufferAllocation,
&allocationInfo) );
if ( allocationInfo.pMappedData )
{
memcpy( allocationInfo.pMappedData, &cameraData, sizeof cameraData );
cameraUniformBufferPtr = static_cast<uint8_t*>(allocationInfo.pMappedData);
}
}
// Descriptors
{
VkDescriptorPoolSize const poolSize = {
.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = renderDevice.getNumFrames(),
};
VkDescriptorPoolCreateInfo const descriptorPoolCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.maxSets = renderDevice.getNumFrames(),
.poolSizeCount = 1,
.pPoolSizes = &poolSize,
};
VK_CHECK( vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, nullptr, &descriptorPool) );
VkDescriptorSetAllocateInfo const descriptorSetAllocateInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.pNext = nullptr,
.descriptorPool = descriptorPool,
.descriptorSetCount = 1,
.pSetLayouts = &descriptorSetLayout,
};
VK_CHECK( vkAllocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSet) );
VkDescriptorBufferInfo const descriptorBufferInfo = {
.buffer = cameraUniformBuffer,
.offset = 0,
.range = sizeof CameraData,
};
VkWriteDescriptorSet writeDescriptorSet = {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.pNext = nullptr,
.dstSet = descriptorSet,
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.pImageInfo = nullptr,
.pBufferInfo = &descriptorBufferInfo,
.pTexelBufferView = nullptr,
};
vkUpdateDescriptorSets( device, 1, &writeDescriptorSet, 0, nullptr );
}
// Barrier Creation
{
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,
};
}
} }
void MiscData::destroy( RenderDevice const& renderDevice ) void MiscData::cleanup(RenderDevice const& renderDevice)
{ {
VkDevice const device = renderDevice.device; VkDevice const device = renderDevice.device;
vkDestroyDescriptorPool( device, Take( descriptorPool ), nullptr ); vkDestroyPipeline(device, trianglePipeline, nullptr);
vmaDestroyBuffer( renderDevice.gpuAllocator, Take( cameraUniformBuffer ), Take( cameraUniformBufferAllocation ) ); vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vmaDestroyBuffer( renderDevice.gpuAllocator, Take( vertexBuffer ), Take( vertexBufferAllocation ) );
vkDestroyPipeline( device, Take( meshPipeline ), nullptr );
vkDestroyPipelineLayout( device, Take( pipelineLayout ), nullptr );
vkDestroyDescriptorSetLayout( device, Take( descriptorSetLayout ), nullptr );
} }

52
MiscData.h
View File

@ -1,55 +1,19 @@
#pragma once #pragma once
#include <array>
#include <volk.h> #include <volk.h>
#include <vma/vk_mem_alloc.h>
#include <glm/glm.hpp>
struct RenderDevice; struct RenderDevice;
struct Vertex
{
float position[4];
float color[4];
};
struct MiscData struct MiscData
{ {
struct CameraData VkPipelineLayout pipelineLayout;
{ VkPipeline trianglePipeline;
glm::mat4x4 modelMatrix;
glm::mat4x4 viewMatrix;
glm::mat4x4 projectionMatrix;
};
uint64_t previousCounter; VkImageMemoryBarrier2 acquireToRenderBarrier;
VkDependencyInfo acquireToRenderDependency;
VkImageMemoryBarrier2 renderToPresentBarrier;
VkDependencyInfo renderToPresentDependency;
VkDescriptorSetLayout descriptorSetLayout; void init(RenderDevice const& renderDevice);
VkPipelineLayout pipelineLayout; void cleanup(RenderDevice const& renderDevice);
VkPipeline meshPipeline;
VkBuffer vertexBuffer;
VmaAllocation vertexBufferAllocation;
size_t vertexBufferSize;
std::array<Vertex, 4> vertices;
glm::vec3 cameraPosition;
glm::vec3 cameraTarget;
CameraData cameraData;
VkBuffer cameraUniformBuffer;
VmaAllocation cameraUniformBufferAllocation;
size_t cameraUniformBufferSize;
uint8_t* cameraUniformBufferPtr;
VkDescriptorPool descriptorPool;
VkDescriptorSet descriptorSet;
VkImageMemoryBarrier2 acquireToRenderBarrier;
VkDependencyInfo acquireToRenderDependency;
VkImageMemoryBarrier2 renderToPresentBarrier;
VkDependencyInfo renderToPresentDependency;
void init( RenderDevice const& renderDevice );
void destroy( RenderDevice const& renderDevice );
}; };

714
RenderDevice.cpp
View File

@ -14,456 +14,426 @@
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::nullopt; 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( VkPhysicalDevice* physicalDevices = reinterpret_cast<VkPhysicalDevice*>(mem->allocate(sizeof(VkPhysicalDevice) * physicalDeviceCount));
sizeof( VkPhysicalDevice ) * physicalDeviceCount )); VK_CHECK(vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices));
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_LogInfo(SDL_LOG_CATEGORY_GPU, "- API Version %d.%d.%d",
SDL_LOG_CATEGORY_GPU, VK_API_VERSION_MAJOR(properties.apiVersion),
"- API Version %d.%d.%d", VK_API_VERSION_MINOR(properties.apiVersion),
VK_API_VERSION_MAJOR( properties.apiVersion ), VK_API_VERSION_PATCH(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( VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast<VkQueueFamilyProperties*>(mem->allocate(sizeof(VkQueueFamilyProperties) * queueFamilyCount));
sizeof( VkQueueFamilyProperties ) * queueFamilyCount )); vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilyProperties);
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( VK_CHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported));
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 ); }
}
ASSERT( physicalDeviceInUse ); mem->restoreState(tempAllocQueueProperties);
ASSERT( directQueueFamilyIndex.has_value() ); }
float priority = 1.0f; ASSERT(physicalDeviceInUse);
VkDeviceQueueCreateInfo queueCreateInfo = { ASSERT(directQueueFamilyIndex.has_value());
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.queueFamilyIndex = directQueueFamilyIndex.value(),
.queueCount = 1,
.pQueuePriorities = &priority,
};
VkPhysicalDeviceVulkan13Features constexpr features13 = { float priority = 1.0f;
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, VkDeviceQueueCreateInfo queueCreateInfo = {
.pNext = nullptr, .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.synchronization2 = true, .pNext = nullptr,
.dynamicRendering = true, .flags = 0,
}; .queueFamilyIndex = directQueueFamilyIndex.value(),
.queueCount = 1,
.pQueuePriorities = &priority,
};
VkPhysicalDeviceFeatures features = { VkPhysicalDeviceVulkan13Features constexpr features13 = {
.depthClamp = true, .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
.samplerAnisotropy = true, .pNext = nullptr,
}; .synchronization2 = true,
.dynamicRendering = true,
};
std::array enabledDeviceExtensions = { VkPhysicalDeviceFeatures features = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME .depthClamp = true,
}; .samplerAnisotropy = true,
};
VkDeviceCreateInfo const deviceCreateInfo = { std::array enabledDeviceExtensions = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, VK_KHR_SWAPCHAIN_EXTENSION_NAME
.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) ); VkDeviceCreateInfo const deviceCreateInfo = {
volkLoadDevice( device ); .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,
};
VmaAllocatorCreateInfo allocatorCreateInfo = { VK_CHECK(vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device));
.flags = 0, volkLoadDevice(device);
.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; VmaAllocatorCreateInfo allocatorCreateInfo = {
VK_CHECK( vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions) ); .flags = 0,
allocatorCreateInfo.pVulkanFunctions = &vkFunctions; .physicalDevice = physicalDeviceInUse,
.device = device,
.preferredLargeHeapBlockSize = 0,
.pAllocationCallbacks = nullptr,
.pDeviceMemoryCallbacks = nullptr,
.pHeapSizeLimit = nullptr,
.pVulkanFunctions = nullptr,
.instance = instance,
.vulkanApiVersion = VK_API_VERSION_1_3,
.pTypeExternalMemoryHandleTypes = nullptr,
};
VK_CHECK( vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator) ); VmaVulkanFunctions vkFunctions;
VK_CHECK(vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions));
allocatorCreateInfo.pVulkanFunctions = &vkFunctions;
vkGetDeviceQueue( device, directQueueFamilyIndex.value(), 0, &directQueue ); VK_CHECK(vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator));
mem->restoreState( tempAllocStart ); vkGetDeviceQueue(device, directQueueFamilyIndex.value(), 0, &directQueue);
}
// Swapchain creation mem->restoreState(tempAllocStart);
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; // Swapchain creation
VK_CHECK( vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities) ); VkExtent2D swapchainExtent = { createInfo.width, createInfo.height };
VkFormat swapchainFormat = VK_FORMAT_UNDEFINED;
VkSwapchainKHR swapchain;
VkImage* swapchainImages;
VkImageView* swapchainViews;
uint32_t swapchainImageCount;
{
auto tempAllocStart = mem->getState();
// Image Count Calculation VkSurfaceCapabilitiesKHR capabilities;
swapchainImageCount = 3; VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities));
if ( capabilities.maxImageCount > 0 )
{
swapchainImageCount = std::min( swapchainImageCount, capabilities.maxImageCount );
}
swapchainImageCount = std::max( swapchainImageCount, capabilities.minImageCount + 1 );
// Image Size calculation // Image Count Calculation
{ swapchainImageCount = 3;
auto [minWidth, minHeight] = capabilities.minImageExtent; if (capabilities.maxImageCount > 0)
auto [maxWidth, maxHeight] = capabilities.maxImageExtent; {
swapchainExtent.width = Clamp( swapchainExtent.width, minWidth, maxWidth ); swapchainImageCount = std::min(swapchainImageCount, capabilities.maxImageCount);
swapchainExtent.height = Clamp( swapchainExtent.height, minHeight, maxHeight ); }
} swapchainImageCount = std::max(swapchainImageCount, capabilities.minImageCount + 1);
uint32_t surfaceFormatCount; // Image Size calculation
vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, nullptr ); {
VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate( auto [minWidth, minHeight] = capabilities.minImageExtent;
sizeof( VkSurfaceFormatKHR ) * surfaceFormatCount )); auto [maxWidth, maxHeight] = capabilities.maxImageExtent;
vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats ); swapchainExtent.width = Clamp(swapchainExtent.width, minWidth, maxWidth);
swapchainExtent.height = Clamp(swapchainExtent.height, minHeight, maxHeight);
}
VkSurfaceFormatKHR format = { uint32_t surfaceFormatCount;
.format = VK_FORMAT_UNDEFINED, vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, nullptr);
.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(sizeof(VkSurfaceFormatKHR*) * surfaceFormatCount));
}; 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;
uint32_t presentModeCount; VkSurfaceFormatKHR format = {
vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, nullptr ); .format = VK_FORMAT_UNDEFINED,
VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate( .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
sizeof( VkPresentModeKHR ) * presentModeCount )); };
vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, presentModes ); 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;
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; uint32_t presentModeCount;
for ( VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount } ) vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, nullptr);
{ VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(sizeof(VkPresentModeKHR*) * presentModeCount));
if ( presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR ) vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, presentModes);
{
presentMode = presentModeIter;
break;
}
if ( presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR ) VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
{ for (VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount })
presentMode = presentModeIter; {
} if (presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR)
} {
presentMode = presentModeIter;
break;
}
mem->restoreState( tempAllocStart ); if (presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR)
{
presentMode = presentModeIter;
}
}
VkSwapchainCreateInfoKHR const swapchainCreateInfo = { mem->restoreState(tempAllocStart);
.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) ); 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,
};
swapchainImageCount = 0; VK_CHECK(vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr, &swapchain));
vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, nullptr );
swapchainImages = reinterpret_cast<VkImage*>(mem->allocate( sizeof( VkImage ) * swapchainImageCount ));
vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, swapchainImages );
swapchainViews = reinterpret_cast<VkImageView*>(mem->allocate( sizeof( VkImageView ) * swapchainImageCount )); swapchainImageCount = 0;
for ( uint32_t i = 0; i != swapchainImageCount; ++i ) vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, nullptr);
{ swapchainImages = reinterpret_cast<VkImage*>(mem->allocate(sizeof(VkImage) * swapchainImageCount));
VkImageViewCreateInfo const viewCreateInfo = { vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, swapchainImages);
.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]) ); swapchainViews = reinterpret_cast<VkImageView*>(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,
}
};
// Init frames. VK_CHECK(vkCreateImageView(device, &viewCreateInfo, nullptr, &swapchainViews[i]));
}
}
Frame* frames = reinterpret_cast<Frame*>(mem->allocate( sizeof( Frame ) * swapchainImageCount )); // Init frames.
for ( uint32_t i = 0; i != swapchainImageCount; ++i )
{
new( frames + i ) Frame( device, directQueueFamilyIndex.value() );
}
Byte* allocation = mem->allocate( sizeof( RenderDevice ), alignof( RenderDevice ) ); Frame* frames = reinterpret_cast<Frame*>(mem->allocate(sizeof(Frame) * swapchainImageCount));
return new( allocation ) RenderDevice{ for (uint32_t i = 0; i != swapchainImageCount; ++i)
instance, {
surface, new (frames + i) Frame(device, directQueueFamilyIndex.value());
physicalDeviceInUse, }
device,
gpuAllocator, Byte* allocation = mem->allocate(sizeof(RenderDevice), alignof(RenderDevice));
directQueue, return new (allocation) RenderDevice{
directQueueFamilyIndex.value(), instance, surface, physicalDeviceInUse,
swapchainFormat, device, gpuAllocator, directQueue, directQueueFamilyIndex.value(),
swapchainExtent, swapchainFormat, swapchainExtent, swapchain, swapchainImages, swapchainViews, frames, swapchainImageCount,
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::destroy() void RenderDevice::cleanup()
{ {
if ( not isInit() ) return; if (not isInit())
return;
for ( Frame& frame : std::span{ frames, swapchainImageCount } ) for (Frame& frame : std::span{ frames, swapchainImageCount })
{ {
frame.destroy( *this ); frame.cleanup(*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);
vmaDestroyAllocator( Take( gpuAllocator ) ); 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( RenderDevice::RenderDevice(VkInstance const instance, VkSurfaceKHR const surface, VkPhysicalDevice const physicalDeviceInUse,
VkInstance const instance, VkDevice const device, VmaAllocator gpuAllocator, VkQueue const directQueue, uint32_t const directQueueFamilyIndex,
VkSurfaceKHR const surface, VkFormat const swapchainFormat, VkExtent2D const swapchainExtent, VkSwapchainKHR const swapchain, VkImage* swapchainImages,
VkPhysicalDevice const physicalDeviceInUse, VkImageView* swapchainViews, Frame* frames, uint32_t const swapchainImageCount)
VkDevice const device, : instance{ instance }
VmaAllocator const gpuAllocator, , surface{ surface }
VkQueue const directQueue, , physicalDeviceInUse{ physicalDeviceInUse }
uint32_t const directQueueFamilyIndex, , device{ device }
VkFormat const swapchainFormat, , gpuAllocator{ gpuAllocator }
VkExtent2D const swapchainExtent, , directQueue{ directQueue }
VkSwapchainKHR const swapchain, , directQueueFamilyIndex{ directQueueFamilyIndex }
VkImage* swapchainImages, , swapchainFormat{ swapchainFormat }
VkImageView* swapchainViews, , swapchainExtent{ swapchainExtent }
Frame* frames, , swapchain{ swapchain }
uint32_t const swapchainImageCount ) , swapchainImages{ swapchainImages }
: instance{ instance } , swapchainViews{ swapchainViews }
, surface{ surface } , frames{ frames }
, physicalDeviceInUse{ physicalDeviceInUse } , swapchainImageCount{ swapchainImageCount }
, 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 destroy(); void cleanup();
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);

16
Mesh.slang → Triangle.slang
View File

@ -15,23 +15,13 @@ struct VertexOut {
float4 vertexColor : CoarseColor; float4 vertexColor : CoarseColor;
}; };
struct CameraData {
float4x4 model;
float4x4 view;
float4x4 proj;
};
ParameterBlock<CameraData> camera;
[shader("vertex")] [shader("vertex")]
VertexOut VertexMain( VertexOut VertexMain(
uint vertexId: SV_VertexID, uint vertexId: SV_VertexID
float4 position,
float4 color,
) { ) {
VertexOut output; VertexOut output;
output.outPosition = mul(camera.proj, mul(camera.view, mul(camera.model, position))); output.outPosition = vertexPos[vertexId];
output.vertexColor = color; output.vertexColor = vertexColors[vertexId];
return output; return output;
} }

BIN
Triangle.spv Normal file
View File

Binary file not shown.

2
VmaImpl.cpp
View File

@ -4,4 +4,4 @@
#pragma warning(disable : 5045) #pragma warning(disable : 5045)
#define VMA_IMPLEMENTATION #define VMA_IMPLEMENTATION
#include <vma/vk_mem_alloc.h> #include <vma/vk_mem_alloc.h>
#pragma warning(pop) #pragma warning(pop)

1
vcpkg.json
View File

@ -3,7 +3,6 @@
"volk", "volk",
"shader-slang", "shader-slang",
"vulkan-memory-allocator", "vulkan-memory-allocator",
"glm",
{ {
"name": "sdl3", "name": "sdl3",
"features": [ "vulkan" ] "features": [ "vulkan" ]