.gitignore

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

AppState.cpp

@@ -3,65 +3,62 @@
 #include <SDL3/SDL_log.h>
 
 #include "GlobalMemory.h"
-#include "MiscData.h"
 #include "RenderDevice.h"
+#include "MiscData.h"
 
 bool AppState::isInit() const
 {
 	return window and renderDevice and renderDevice->isInit();
 }
 
-void AppState::destroy()
+void AppState::cleanup()
 {
-  if ( !isInit() ) return;
+	if (!isInit()) return;
 
 	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 }
-  , 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),
+AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t const height)
-    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;
 	}
 
 	auto state = memory->getState();
-  RenderDevice* renderDevice = CreateRenderDevice( memory, { .window = window } );
+	RenderDevice* renderDevice = CreateRenderDevice(memory, { .window = window });
-  if ( !renderDevice->isInit() )
+	if (!renderDevice->isInit())
 	{
-    SDL_LogError( SDL_LOG_CATEGORY_APPLICATION, "RenderDevice failed to init" );
+		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "RenderDevice failed to init");
 		return nullptr;
 	}
 	(void)state;
 
-  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;
 }
 
 AppState::~AppState()
 {
-  ASSERT( !isInit() );
+	cleanup();
 }

AppState.h

@@ -2,9 +2,8 @@
 
 #include <memory>
 
-struct SDL_Window;
-
 struct GlobalMemory;
+struct SDL_Window;
 struct RenderDevice;
 struct MiscData;
 
@@ -14,19 +13,18 @@ struct AppState
 	RenderDevice* renderDevice;
 	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* CreateAppState( GlobalMemory* memory, uint32_t const width, uint32_t const height );
+AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t const height);

Blaze.cpp

@@ -10,7 +10,6 @@
 
 #define SDL_MAIN_USE_CALLBACKS 1
 #include <memory>
-#include <glm/ext/matrix_transform.hpp>
 #include <SDL3/SDL.h>
 #include <SDL3/SDL_main.h>
 #include <SDL3/SDL_filesystem.h>
@@ -30,38 +29,39 @@ constexpr uint32_t NUM_FRAMES = 3;
 
 using Byte = uint8_t;
 
-constexpr size_t operator ""_KiB( size_t const value )
+constexpr size_t operator ""_KiB(size_t const value)
 {
 	return value * 1024;
 }
 
-constexpr size_t operator ""_MiB( size_t const value )
+constexpr size_t operator ""_MiB(size_t const value)
 {
 	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;
 }
 
 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);
 
-  if ( !appState.isInit() )
+	if (!appState.isInit())
 	{
 		return SDL_APP_FAILURE;
 	}
@@ -69,48 +69,21 @@ SDL_AppResult SDL_AppInit( void** pAppState, int, char** )
 	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);
 	RenderDevice& renderDevice = *appState.renderDevice;
 	MiscData& misc = *appState.miscData;
 	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,
-      1,
-      &currentFrame.frameReadyToReuse,
-      VK_TRUE,
-      std::numeric_limits<uint32_t>::max()) );
 	// All resources of frame 'frameIndex' are free.
 
-  uint64_t const previousCounter = misc.previousCounter;
-  uint64_t const currentCounter  = SDL_GetPerformanceCounter();
-  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;
-  double fps = 1.0 / deltaTime;
-  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.cameraData.modelMatrix,
-    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;
-  VK_CHECK(
+	VK_CHECK(vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits<uint32_t>::max(), currentFrame.imageAcquiredSemaphore, nullptr, &currentImageIndex));
-    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.renderToPresentBarrier.image = renderDevice.swapchainImages[currentImageIndex];
@@ -128,7 +101,7 @@ SDL_AppResult SDL_AppIterate( void* appstate )
 		.float32 = { 0.0f, 0.0f, 0.0f, 1.0f },
 	};
 
-  VK_CHECK( vkBeginCommandBuffer(cmd, &beginInfo) );
+	VK_CHECK(vkBeginCommandBuffer(cmd, &beginInfo));
 	{
 		VkRenderingAttachmentInfo const attachmentInfo = {
 			.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
@@ -140,14 +113,14 @@ SDL_AppResult SDL_AppIterate( void* appstate )
 			.resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED,
 			.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
 			.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
-      .clearValue = { .color = BLACK_CLEAR },
+			.clearValue = {.color = BLACK_CLEAR},
 		};
 
 		VkRenderingInfo renderingInfo = {
 			.sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
 			.pNext = nullptr,
 			.flags = 0,
-      .renderArea = { .offset = { 0, 0 }, .extent = renderDevice.swapchainExtent },
+			.renderArea = {.offset = {0,0}, .extent = renderDevice.swapchainExtent},
 			.layerCount = 1,
 			.viewMask = 0,
 			.colorAttachmentCount = 1,
@@ -156,8 +129,8 @@ SDL_AppResult SDL_AppIterate( void* appstate )
 			.pStencilAttachment = nullptr,
 		};
 
-    vkCmdPipelineBarrier2( cmd, &misc.acquireToRenderDependency );
+		vkCmdPipelineBarrier2(cmd, &misc.acquireToRenderDependency);
-    vkCmdBeginRendering( cmd, &renderingInfo );
+		vkCmdBeginRendering(cmd, &renderingInfo);
 		{
 			VkViewport viewport = {
 				.x = 0,
@@ -167,32 +140,22 @@ SDL_AppResult SDL_AppIterate( void* appstate )
 				.minDepth = 0.0f,
 				.maxDepth = 1.0f,
 			};
-      vkCmdSetViewport( cmd, 0, 1, &viewport );
+			vkCmdSetViewport(cmd, 0, 1, &viewport);
 			VkRect2D scissor = {
-        .offset = { 0, 0 },
+				.offset = {0, 0},
 				.extent = renderDevice.swapchainExtent,
 			};
-      vkCmdSetScissor( cmd, 0, 1, &scissor );
+			vkCmdSetScissor(cmd, 0, 1, &scissor);
 
 			// Render Something?
-      vkCmdBindPipeline( cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.meshPipeline );
+			vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline);
-      VkDeviceSize constexpr offset = 0;
+			vkCmdDraw(cmd, 3, 1, 0, 0);
-      vkCmdBindVertexBuffers( cmd, 0, 1, &misc.vertexBuffer, &offset );
+
-      vkCmdBindDescriptorSets(
-        cmd,
-        VK_PIPELINE_BIND_POINT_GRAPHICS,
-        misc.pipelineLayout,
-        0,
-        1,
-        &misc.descriptorSet,
-        0,
-        nullptr );
-      vkCmdDraw( cmd, static_cast<uint32_t>(misc.vertices.size()), 1, 0, 0 );
 		}
-    vkCmdEndRendering( cmd );
+		vkCmdEndRendering(cmd);
-    vkCmdPipelineBarrier2( cmd, &misc.renderToPresentDependency );
+		vkCmdPipelineBarrier2(cmd, &misc.renderToPresentDependency);
 	}
-  VK_CHECK( vkEndCommandBuffer(cmd) );
+	VK_CHECK(vkEndCommandBuffer(cmd));
 
 	VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 	VkSubmitInfo const submitInfo = {
@@ -206,7 +169,7 @@ SDL_AppResult SDL_AppIterate( void* appstate )
 		.signalSemaphoreCount = 1,
 		.pSignalSemaphores = &currentFrame.renderFinishedSemaphore,
 	};
-  VK_CHECK( vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse) );
+	VK_CHECK(vkQueueSubmit(renderDevice.directQueue, 1, &submitInfo, currentFrame.frameReadyToReuse));
 
 	VkPresentInfoKHR const presentInfo = {
 		.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
@@ -219,16 +182,16 @@ SDL_AppResult SDL_AppIterate( void* appstate )
 		.pResults = nullptr,
 	};
 
-  VK_CHECK( vkQueuePresentKHR(renderDevice.directQueue, &presentInfo) );
+	VK_CHECK(vkQueuePresentKHR(renderDevice.directQueue, &presentInfo));
 
 	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;
 	}
@@ -236,11 +199,11 @@ SDL_AppResult SDL_AppEvent( void*, SDL_Event* event )
 	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.vcxproj

@@ -163,7 +163,7 @@
       </SubType>
     </None>
     <None Include="README.md" />
-    <CustomBuild Include="Mesh.slang">
+    <CustomBuild Include="Triangle.slang">
       <FileType>Document</FileType>
       <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>
@@ -183,6 +183,7 @@
     <ClInclude Include="AppState.h" />
     <ClInclude Include="Frame.h" />
     <ClInclude Include="GlobalMemory.h" />
+    <ClInclude Include="MemoryUtils.h" />
     <ClInclude Include="MacroUtils.h" />
     <ClInclude Include="MathUtil.h" />
     <ClInclude Include="MiscData.h" />

Blaze.vcxproj.filters

@@ -58,7 +58,7 @@
     </None>
   </ItemGroup>
   <ItemGroup>
-    <CustomBuild Include="Mesh.slang">
+    <CustomBuild Include="Triangle.slang">
       <Filter>Shader Files</Filter>
     </CustomBuild>
   </ItemGroup>
@@ -75,6 +75,9 @@
     <ClInclude Include="MathUtil.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="MemoryUtils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="AppState.h">
       <Filter>Header Files</Filter>
     </ClInclude>

Frame.cpp

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

Frame.h

@@ -15,9 +15,10 @@ struct Frame
 
 	[[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();
 };
+

GlobalMemory.cpp

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

GlobalMemory.h

@@ -18,17 +18,17 @@ struct GlobalMemory
 	size_t available;
 	size_t capacity;
 
-  void init( size_t size );
+	void init(size_t const size);
 
 	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.
 	[[nodiscard]] State getState() const;
 
 	// Call this before permanent allocations.
-  void restoreState( State const& state );
+	void restoreState(State const& state);
 };

MathUtil.h

@@ -2,8 +2,8 @@
 
 #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));
 }

MemoryUtils.h

@@ -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;

MiscData.cpp

@@ -6,23 +6,18 @@
 #include "MacroUtils.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;
-
-  previousCounter = 0;
-
-  // Pipeline Creation
 	{
 		size_t dataSize;
-    void*  rawData = SDL_LoadFile( "Mesh.spv", &dataSize );
+		void* rawData = SDL_LoadFile("Triangle.spv", &dataSize);
-    ASSERT( dataSize % 4 == 0 );
+		ASSERT(dataSize % 4 == 0);
 
-    if ( !rawData )
+		if (not rawData)
 		{
-      SDL_LogError( SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError() );
+			SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError());
 			abort();
 		}
 
@@ -37,35 +32,18 @@ void MiscData::init( RenderDevice const& renderDevice )
 		};
 
 		VkShaderModule shaderModule;
-    VK_CHECK( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule) );
+		VK_CHECK(vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule));
 
-    VkDescriptorSetLayoutBinding constexpr descriptorSetLayoutBinding = {
+		VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = {
-      .binding = 0,
-      .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-      .descriptorCount = 1,
-      .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
-      .pImmutableSamplers = nullptr,
-    };
-
-    VkDescriptorSetLayoutCreateInfo const descriptorSetLayoutCreateInfo = {
-      .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-      .pNext = nullptr,
-      .flags = 0,
-      .bindingCount = 1,
-      .pBindings = &descriptorSetLayoutBinding,
-    };
-    VK_CHECK( vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCreateInfo, nullptr, &descriptorSetLayout) );
-
-    VkPipelineLayoutCreateInfo const pipelineLayoutCreateInfo = {
 			.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 			.pNext = nullptr,
 			.flags = 0,
-      .setLayoutCount = 1,
+			.setLayoutCount = 0,
-      .pSetLayouts = &descriptorSetLayout,
+			.pSetLayouts = nullptr,
 			.pushConstantRangeCount = 0,
 			.pPushConstantRanges = nullptr,
 		};
-    VK_CHECK( vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) );
+		VK_CHECK(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));
 
 		std::array stages = {
 			VkPipelineShaderStageCreateInfo{
@@ -88,42 +66,21 @@ void MiscData::init( RenderDevice const& renderDevice )
 			}
 		};
 
-    VkVertexInputBindingDescription constexpr bindingDescription = {
+		VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = {
-      .binding = 0,
-      .stride = sizeof( Vertex ),
-      .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
-    };
-
-    std::array attributeDescriptions = {
-      VkVertexInputAttributeDescription{
-        .location = 0,
-        .binding = 0,
-        .format = VK_FORMAT_R32G32B32A32_SFLOAT,
-        .offset = offsetof( Vertex, position ),
-      },
-      VkVertexInputAttributeDescription{
-        .location = 1,
-        .binding = 0,
-        .format = VK_FORMAT_R32G32B32A32_SFLOAT,
-        .offset = offsetof( Vertex, color ),
-      },
-    };
-
-    VkPipelineVertexInputStateCreateInfo const vertexInputState = {
 			.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 			.pNext = nullptr,
 			.flags = 0,
-      .vertexBindingDescriptionCount = 1,
+			.vertexBindingDescriptionCount = 0,
-      .pVertexBindingDescriptions = &bindingDescription,
+			.pVertexBindingDescriptions = nullptr,
-      .vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size()),
+			.vertexAttributeDescriptionCount = 0,
-      .pVertexAttributeDescriptions = attributeDescriptions.data(),
+			.pVertexAttributeDescriptions = nullptr,
 		};
 
 		VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = {
 			.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
 			.pNext = nullptr,
 			.flags = 0,
-      .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+			.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 			.primitiveRestartEnable = VK_FALSE,
 		};
 
@@ -209,7 +166,7 @@ void MiscData::init( RenderDevice const& renderDevice )
 			.logicOp = VK_LOGIC_OP_COPY,
 			.attachmentCount = 1,
 			.pAttachments = &colorBlendAttachmentState,
-      .blendConstants = { 0.0f, 0.0f, 0.0f, 0.0f },
+			.blendConstants = {0.0f, 0.0f, 0.0f, 0.0f},
 		};
 
 		std::array constexpr dynamicStates = {
@@ -253,191 +210,13 @@ void MiscData::init( RenderDevice const& renderDevice )
 			.basePipelineIndex = 0,
 		};
 
-    VK_CHECK( vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &meshPipeline) );
+		VK_CHECK(vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &trianglePipeline));
 
-    vkDestroyShaderModule( device, shaderModule, nullptr );
+		vkDestroyShaderModule(device, shaderModule, nullptr);
 
-    SDL_free( rawData );
+		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,
@@ -499,18 +278,12 @@ void MiscData::init( RenderDevice const& renderDevice )
 		.imageMemoryBarrierCount = 1,
 		.pImageMemoryBarriers = &renderToPresentBarrier,
 	};
-  }
 }
 
-void MiscData::destroy( RenderDevice const& renderDevice )
+void MiscData::cleanup(RenderDevice const& renderDevice)
 {
 	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 );
 }

MiscData.h

@@ -1,55 +1,19 @@
 #pragma once
 
-#include <array>
 #include <volk.h>
 
-#include <vma/vk_mem_alloc.h>
-
-#include <glm/glm.hpp>
-
 struct RenderDevice;
 
-struct Vertex
-{
-  float position[4];
-  float color[4];
-};
-
 struct MiscData
 {
-  struct CameraData
-  {
-    glm::mat4x4 modelMatrix;
-    glm::mat4x4 viewMatrix;
-    glm::mat4x4 projectionMatrix;
-  };
-
-  uint64_t previousCounter;
-
-  VkDescriptorSetLayout descriptorSetLayout;
 	VkPipelineLayout pipelineLayout;
-  VkPipeline            meshPipeline;
+	VkPipeline trianglePipeline;
-
-  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 init(RenderDevice const& renderDevice);
-  void destroy( RenderDevice const& renderDevice );
+	void cleanup(RenderDevice const& renderDevice);
 };

RenderDevice.cpp

@@ -14,13 +14,13 @@
 
 RenderDevice::~RenderDevice()
 {
-  ASSERT( !isInit() );
+	ASSERT(!isInit());
 }
 
 // TODO: Failure Handling
-RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo )
+RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo)
 {
-  ASSERT( createInfo.window );
+	ASSERT(createInfo.window);
 
 	volkInitialize();
 
@@ -31,14 +31,14 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 			.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
 			.pNext = nullptr,
 			.pApplicationName = "Test",
-      .applicationVersion = VK_MAKE_API_VERSION( 0, 0, 1, 0 ),
+			.applicationVersion = VK_MAKE_API_VERSION(0, 0, 1, 0),
 			.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,
 		};
 
 		uint32_t instanceExtensionCount;
-    char const* const* instanceExtensions = SDL_Vulkan_GetInstanceExtensions( &instanceExtensionCount );
+		char const* const* instanceExtensions = SDL_Vulkan_GetInstanceExtensions(&instanceExtensionCount);
 
 		VkInstanceCreateInfo const instanceCreateInfo = {
 			.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
@@ -51,66 +51,62 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 			.ppEnabledExtensionNames = instanceExtensions,
 		};
 
-    VK_CHECK( vkCreateInstance(&instanceCreateInfo, nullptr, &instance) );
+		VK_CHECK(vkCreateInstance(&instanceCreateInfo, nullptr, &instance));
-    volkLoadInstance( instance );
+		volkLoadInstance(instance);
 	}
 
 	VkSurfaceKHR surface;
 	// Create Surface
-  ASSERT( SDL_Vulkan_CreateSurface(createInfo.window, instance, nullptr, &surface) );
+	ASSERT(SDL_Vulkan_CreateSurface(createInfo.window, instance, nullptr, &surface));
 
 	VkPhysicalDevice physicalDeviceInUse = nullptr;
 	VkDevice device = nullptr;
 	VmaAllocator gpuAllocator = nullptr;
-  std::optional<uint32_t> directQueueFamilyIndex = std::nullopt;
+	std::optional<uint32_t> directQueueFamilyIndex;
 	VkQueue directQueue = nullptr;
 	// Create Device and Queue
 	{
 		auto tempAllocStart = mem->getState();
 
 		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();
 
 			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;
-      if ( (properties.apiVersion & (~API_PATCH_BITS)) < VK_API_VERSION_1_3 )
+			if ((properties.apiVersion & (~API_PATCH_BITS)) < VK_API_VERSION_1_3)
 			{
 				continue;
 			}
 
-      if ( properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU )
+			if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
 			{
 				continue;
 			}
 
 			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];
 
@@ -119,46 +115,46 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 				bool hasTransferSupport = 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;
-          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;
-          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;
-          SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "-- Transfer" );
+					SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "-- Transfer");
 				}
 
 				VkBool32 isSurfaceSupported;
-        VK_CHECK(
+				VK_CHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported));
-          vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported) );
 
-        if ( isSurfaceSupported )
+				if (isSurfaceSupported)
 				{
 					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;
 					directQueueFamilyIndex = queueFamilyIndex;
 					break;
 				}
+
 			}
 
-      mem->restoreState( tempAllocQueueProperties );
+			mem->restoreState(tempAllocQueueProperties);
 		}
 
-    ASSERT( physicalDeviceInUse );
+		ASSERT(physicalDeviceInUse);
-    ASSERT( directQueueFamilyIndex.has_value() );
+		ASSERT(directQueueFamilyIndex.has_value());
 
 		float priority = 1.0f;
 		VkDeviceQueueCreateInfo queueCreateInfo = {
@@ -199,8 +195,8 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 			.pEnabledFeatures = &features,
 		};
 
-    VK_CHECK( vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device) );
+		VK_CHECK(vkCreateDevice(physicalDeviceInUse, &deviceCreateInfo, nullptr, &device));
-    volkLoadDevice( device );
+		volkLoadDevice(device);
 
 		VmaAllocatorCreateInfo allocatorCreateInfo = {
 			.flags = 0,
@@ -217,14 +213,14 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 		};
 
 		VmaVulkanFunctions vkFunctions;
-    VK_CHECK( vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions) );
+		VK_CHECK(vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vkFunctions));
 		allocatorCreateInfo.pVulkanFunctions = &vkFunctions;
 
-    VK_CHECK( vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator) );
+		VK_CHECK(vmaCreateAllocator(&allocatorCreateInfo, &gpuAllocator));
 
-    vkGetDeviceQueue( device, directQueueFamilyIndex.value(), 0, &directQueue );
+		vkGetDeviceQueue(device, directQueueFamilyIndex.value(), 0, &directQueue);
 
-    mem->restoreState( tempAllocStart );
+		mem->restoreState(tempAllocStart);
 	}
 
 	// Swapchain creation
@@ -238,80 +234,75 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 		auto tempAllocStart = mem->getState();
 
 		VkSurfaceCapabilitiesKHR capabilities;
-    VK_CHECK( vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities) );
+		VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDeviceInUse, surface, &capabilities));
 
 		// Image Count Calculation
 		swapchainImageCount = 3;
-    if ( capabilities.maxImageCount > 0 )
+		if (capabilities.maxImageCount > 0)
 		{
-      swapchainImageCount = std::min( swapchainImageCount, capabilities.maxImageCount );
+			swapchainImageCount = std::min(swapchainImageCount, capabilities.maxImageCount);
 		}
-    swapchainImageCount = std::max( swapchainImageCount, capabilities.minImageCount + 1 );
+		swapchainImageCount = std::max(swapchainImageCount, capabilities.minImageCount + 1);
 
 		// Image Size calculation
 		{
 			auto [minWidth, minHeight] = capabilities.minImageExtent;
 			auto [maxWidth, maxHeight] = capabilities.maxImageExtent;
-      swapchainExtent.width      = Clamp( swapchainExtent.width, minWidth, maxWidth );
+			swapchainExtent.width = Clamp(swapchainExtent.width, minWidth, maxWidth);
-      swapchainExtent.height     = Clamp( swapchainExtent.height, minHeight, maxHeight );
+			swapchainExtent.height = Clamp(swapchainExtent.height, minHeight, maxHeight);
 		}
 
 		uint32_t surfaceFormatCount;
-    vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, nullptr );
+		vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, nullptr);
-    VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(
+		VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(sizeof(VkSurfaceFormatKHR*) * surfaceFormatCount));
-      sizeof( VkSurfaceFormatKHR ) * surfaceFormatCount ));
+		vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats);
-    vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats );
 
 		VkSurfaceFormatKHR format = {
 			.format = VK_FORMAT_UNDEFINED,
 			.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
 		};
-    for ( auto& surfaceFormat : std::span{ surfaceFormats, surfaceFormatCount } )
+		for (auto& surfaceFormat : std::span{ surfaceFormats, surfaceFormatCount })
 		{
-      if ( surfaceFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR )
+			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 )
 			{
+				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 )
+				if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_SRGB) {
-        {
 					format = surfaceFormat;
 					break;
 				}
-        if ( surfaceFormat.format == VK_FORMAT_R8G8B8A8_UNORM )
+				if (surfaceFormat.format == VK_FORMAT_R8G8B8A8_UNORM) {
-        {
 					format = surfaceFormat;
 				}
 			}
 		}
-    ASSERT( format.format != VK_FORMAT_UNDEFINED );
+		ASSERT(format.format != VK_FORMAT_UNDEFINED);
 		swapchainFormat = format.format;
 
 		uint32_t presentModeCount;
-    vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, nullptr );
+		vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, nullptr);
-    VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(
+		VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(sizeof(VkPresentModeKHR*) * presentModeCount));
-      sizeof( VkPresentModeKHR ) * presentModeCount ));
+		vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDeviceInUse, surface, &presentModeCount, presentModes);
-    vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, presentModes );
 
 		VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
-    for ( VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount } )
+		for (VkPresentModeKHR presentModeIter : std::span{ presentModes, presentModeCount })
 		{
-      if ( presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR )
+			if (presentModeIter == VK_PRESENT_MODE_FIFO_RELAXED_KHR)
 			{
 				presentMode = presentModeIter;
 				break;
 			}
 
-      if ( presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR )
+			if (presentModeIter == VK_PRESENT_MODE_MAILBOX_KHR)
 			{
 				presentMode = presentModeIter;
 			}
 		}
 
-    mem->restoreState( tempAllocStart );
+		mem->restoreState(tempAllocStart);
 
 		VkSwapchainCreateInfoKHR const swapchainCreateInfo = {
 			.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
@@ -334,16 +325,15 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 			.oldSwapchain = nullptr,
 		};
 
-    VK_CHECK( vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr, &swapchain) );
+		VK_CHECK(vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr, &swapchain));
 
 		swapchainImageCount = 0;
-    vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, nullptr );
+		vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, nullptr);
-    swapchainImages = reinterpret_cast<VkImage*>(mem->allocate( sizeof( VkImage ) * swapchainImageCount ));
+		swapchainImages = reinterpret_cast<VkImage*>(mem->allocate(sizeof(VkImage) * swapchainImageCount));
-    vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, swapchainImages );
+		vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, swapchainImages);
 
-    swapchainViews = reinterpret_cast<VkImageView*>(mem->allocate( sizeof( VkImageView ) * swapchainImageCount ));
+		swapchainViews = reinterpret_cast<VkImageView*>(mem->allocate(sizeof(VkImageView) * swapchainImageCount));
-    for ( uint32_t i = 0; i != swapchainImageCount; ++i )
+		for (uint32_t i = 0; i != swapchainImageCount; ++i) {
-    {
 			VkImageViewCreateInfo const viewCreateInfo = {
 				.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 				.pNext = nullptr,
@@ -366,34 +356,23 @@ RenderDevice* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo co
 				}
 			};
 
-      VK_CHECK( vkCreateImageView(device, &viewCreateInfo, nullptr, &swapchainViews[i]) );
+			VK_CHECK(vkCreateImageView(device, &viewCreateInfo, nullptr, &swapchainViews[i]));
 		}
 	}
 
 	// Init frames.
 
-  Frame* frames = reinterpret_cast<Frame*>(mem->allocate( sizeof( Frame ) * swapchainImageCount ));
+	Frame* frames = reinterpret_cast<Frame*>(mem->allocate(sizeof(Frame) * swapchainImageCount));
-  for ( uint32_t i = 0; i != swapchainImageCount; ++i )
+	for (uint32_t i = 0; i != swapchainImageCount; ++i)
 	{
-    new( frames + i ) Frame( device, directQueueFamilyIndex.value() );
+		new (frames + i) Frame(device, directQueueFamilyIndex.value());
 	}
 
-  Byte* allocation = mem->allocate( sizeof( RenderDevice ), alignof( RenderDevice ) );
+	Byte* allocation = mem->allocate(sizeof(RenderDevice), alignof(RenderDevice));
-  return new( allocation ) RenderDevice{
+	return new (allocation) RenderDevice{
-    instance,
+		instance, surface, physicalDeviceInUse,
-    surface,
+		device, gpuAllocator, directQueue, directQueueFamilyIndex.value(),
-    physicalDeviceInUse,
+		swapchainFormat, swapchainExtent, swapchain, swapchainImages, swapchainViews, frames, swapchainImageCount,
-    device,
-    gpuAllocator,
-    directQueue,
-    directQueueFamilyIndex.value(),
-    swapchainFormat,
-    swapchainExtent,
-    swapchain,
-    swapchainImages,
-    swapchainViews,
-    frames,
-    swapchainImageCount,
 	};
 }
 
@@ -402,35 +381,35 @@ inline bool RenderDevice::isInit() const
 	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();
 }
 
 void RenderDevice::waitIdle() const
 {
-  VK_CHECK( vkDeviceWaitIdle(device) );
+	VK_CHECK(vkDeviceWaitIdle(device));
 }
 
 uint32_t RenderDevice::getNumFrames() const
@@ -438,21 +417,10 @@ uint32_t RenderDevice::getNumFrames() const
 	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,
-  VmaAllocator const     gpuAllocator,
-  VkQueue const          directQueue,
-  uint32_t const         directQueueFamilyIndex,
-  VkFormat const         swapchainFormat,
-  VkExtent2D const       swapchainExtent,
-  VkSwapchainKHR const   swapchain,
-  VkImage*               swapchainImages,
-  VkImageView*           swapchainViews,
-  Frame*                 frames,
-  uint32_t const         swapchainImageCount )
 	: instance{ instance }
 	, surface{ surface }
 	, physicalDeviceInUse{ physicalDeviceInUse }
@@ -466,4 +434,6 @@ RenderDevice::RenderDevice(
 	, swapchainImages{ swapchainImages }
 	, swapchainViews{ swapchainViews }
 	, frames{ frames }
-  , swapchainImageCount{ swapchainImageCount } {}
+	, swapchainImageCount{ swapchainImageCount }
+{
+}

RenderDevice.h

@@ -44,7 +44,7 @@ struct RenderDevice
 	uint32_t frameIndex = 0;
 
 	[[nodiscard]] bool isInit() const;
-  void                   destroy();
+	void cleanup();
 	void waitIdle() const;
 	[[nodiscard]] uint32_t getNumFrames() const;
 
@@ -68,13 +68,13 @@ struct RenderDevice
 		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* CreateRenderDevice( GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo );
+RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo const& createInfo);

Triangle.slang

@@ -15,23 +15,13 @@ struct VertexOut {
     float4 vertexColor : CoarseColor;
 };
 
-struct CameraData {
-    float4x4 model;
-    float4x4 view;
-    float4x4 proj;
-};
-
-ParameterBlock<CameraData> camera;
-
 [shader("vertex")]
 VertexOut VertexMain(
-    uint vertexId: SV_VertexID,
+    uint vertexId: SV_VertexID
-    float4 position,
-    float4 color,
 ) {
     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;
 }
 

vcpkg.json

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