VertexBuffer ingestion and Camera.

.gitignore

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

AppState.cpp

@@ -3,35 +3,38 @@
 #include <SDL3/SDL_log.h>
 
 #include "GlobalMemory.h"
-#include "RenderDevice.h"
 #include "MiscData.h"
+#include "RenderDevice.h"
 
 bool AppState::isInit() const
 {
   return window and renderDevice and renderDevice->isInit();
 }
 
-void AppState::cleanup()
+void AppState::destroy()
 {
   if ( !isInit() ) return;
 
   renderDevice->waitIdle();
 
-	Take(miscData)->cleanup(*renderDevice);
+  Take( miscData )->destroy( *renderDevice );
 
-	Take(renderDevice)->cleanup();
+  Take( renderDevice )->destroy();
   SDL_DestroyWindow( Take( window ) );
 }
 
-AppState::AppState(SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData): window{ window }
+AppState::AppState( SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData )
+  : window{ window }
   , renderDevice{ renderDevice }
-	, miscData{ miscData }
+  , miscData{ miscData } {}
-{
-}
 
 AppState* CreateAppState( GlobalMemory* memory, uint32_t const width, uint32_t const height )
 {
-	SDL_Window* window = SDL_CreateWindow("Blaze Test", static_cast<int>(width), static_cast<int>(height), SDL_WINDOW_VULKAN);
+  SDL_Window* window = SDL_CreateWindow(
+    "Blaze Test",
+    static_cast<int>(width),
+    static_cast<int>(height),
+    SDL_WINDOW_VULKAN );
   if ( !window )
   {
     SDL_LogError( SDL_LOG_CATEGORY_APPLICATION, "%s", SDL_GetError() );
@@ -60,5 +63,5 @@ AppState* CreateAppState(GlobalMemory* memory, uint32_t const width, uint32_t co
 
 AppState::~AppState()
 {
-	cleanup();
+  ASSERT( !isInit() );
 }

AppState.h

@@ -2,8 +2,9 @@
 
 #include <memory>
 
-struct GlobalMemory;
 struct SDL_Window;
+
+struct GlobalMemory;
 struct RenderDevice;
 struct MiscData;
 
@@ -13,8 +14,9 @@ struct AppState
   RenderDevice* renderDevice;
   MiscData*     miscData;
 
-	[[nodiscard]] bool isInit() const;
+  [[nodiscard]]
-	void cleanup();
+  bool isInit() const;
+  void destroy();
 
   AppState( SDL_Window* window, RenderDevice* renderDevice, MiscData* miscData );
 

Blaze.cpp

@@ -10,6 +10,7 @@
 
 #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>
@@ -56,8 +57,7 @@ SDL_AppResult SDL_AppInit(void** pAppState, int, char**)
   Blaze::Global::g_Memory.init( 128_MiB );
 
   *pAppState = CreateAppState( &Blaze::Global::g_Memory, WIDTH, HEIGHT );
-	if (!*pAppState)
+  if ( !*pAppState ) return SDL_APP_FAILURE;
-		return SDL_APP_FAILURE;
 
   AppState& appState = *static_cast<AppState*>(*pAppState);
 
@@ -69,6 +69,8 @@ SDL_AppResult SDL_AppInit(void** pAppState, int, char**)
   return SDL_APP_CONTINUE;
 }
 
+char g_buf[1000];
+
 SDL_AppResult SDL_AppIterate( void* appstate )
 {
   AppState&     appState     = *static_cast<AppState*>(appstate);
@@ -76,11 +78,36 @@ SDL_AppResult SDL_AppIterate(void* appstate)
   MiscData&     misc         = *appState.miscData;
   Frame&        currentFrame = renderDevice.frames[renderDevice.frameIndex];
 
-	VK_CHECK(vkWaitForFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse, VK_TRUE, std::numeric_limits<uint32_t>::max()));
+  VK_CHECK(
+    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(vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits<uint32_t>::max(), currentFrame.imageAcquiredSemaphore, nullptr, &currentImageIndex));
+  VK_CHECK(
+    vkAcquireNextImageKHR(renderDevice.device, renderDevice.swapchain, std::numeric_limits<uint32_t>::max(),
+      currentFrame.imageAcquiredSemaphore, nullptr, &currentImageIndex) );
 
   VK_CHECK( vkResetFences(renderDevice.device, 1, &currentFrame.frameReadyToReuse) );
   VK_CHECK( vkResetCommandPool(renderDevice.device, currentFrame.commandPool, 0) );
@@ -148,9 +175,19 @@ SDL_AppResult SDL_AppIterate(void* appstate)
       vkCmdSetScissor( cmd, 0, 1, &scissor );
 
       // Render Something?
-			vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.trianglePipeline);
+      vkCmdBindPipeline( cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, misc.meshPipeline );
-			vkCmdDraw(cmd, 3, 1, 0, 0);
+      VkDeviceSize constexpr offset = 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 );
     vkCmdPipelineBarrier2( cmd, &misc.renderToPresentDependency );
@@ -203,7 +240,7 @@ void SDL_AppQuit(void* appstate, SDL_AppResult)
 {
   AppState* appState = static_cast<AppState*>(appstate);
 
-	appState->cleanup();
+  appState->destroy();
 
   Blaze::Global::g_Memory.destroy();
 }

Blaze.vcxproj

@@ -163,7 +163,7 @@
       </SubType>
     </None>
     <None Include="README.md" />
-    <CustomBuild Include="Triangle.slang">
+    <CustomBuild Include="Mesh.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,7 +183,6 @@
     <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="Triangle.slang">
+    <CustomBuild Include="Mesh.slang">
       <Filter>Shader Files</Filter>
     </CustomBuild>
   </ItemGroup>
@@ -75,9 +75,6 @@
     <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

@@ -45,7 +45,7 @@ Frame::Frame(VkDevice const device, uint32_t const directQueueFamilyIndex)
   VK_CHECK( vkCreateFence(device, &fenceCreateInfo, nullptr, &frameReadyToReuse) );
 }
 
-void Frame::cleanup(RenderDevice const& renderDevice)
+void Frame::destroy( RenderDevice const& renderDevice )
 {
   if ( !isInit() ) return;
 

Frame.h

@@ -17,8 +17,7 @@ struct Frame
 
   Frame( VkDevice device, uint32_t directQueueFamilyIndex );
 
-	void cleanup(RenderDevice const& renderDevice);
+  void destroy( RenderDevice const& renderDevice );
 
   ~Frame();
 };
-

GlobalMemory.cpp

@@ -25,7 +25,13 @@ Byte* GlobalMemory::allocate(size_t const size)
   Byte* retVal = memory;
   memory += size;
   available -= size;
-	SDL_LogInfo(SDL_LOG_CATEGORY_SYSTEM, "ALLOC: %p -> %p (%llu) (avail: %llu)", reinterpret_cast<void*>(retVal), reinterpret_cast<void*>(memory), size, available);
+  SDL_LogInfo(
+    SDL_LOG_CATEGORY_SYSTEM,
+    "ALLOC: %p -> %p (%llu) (avail: %llu)",
+    reinterpret_cast<void*>(retVal),
+    reinterpret_cast<void*>(memory),
+    size,
+    available );
 
   return retVal;
 }
@@ -57,8 +63,8 @@ GlobalMemory::State GlobalMemory::getState() const
 
 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 );
   memory    = state.memory;
   available = state.available;

GlobalMemory.h

@@ -18,13 +18,13 @@ struct GlobalMemory
   size_t available;
   size_t capacity;
 
-	void init(size_t const size);
+  void init( size_t size );
 
   void destroy();
 
-	Byte* allocate(size_t const size);
+  Byte* allocate( size_t size );
 
-	Byte* allocate(size_t const size, size_t const alignment);
+  Byte* allocate( size_t size, size_t alignment );
 
   // Do not do any permanent allocations after calling this.
   [[nodiscard]] State getState() const;

MemoryUtils.h

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

Mesh.slang

@@ -15,13 +15,23 @@ 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 = vertexPos[vertexId];
+    output.outPosition = mul(camera.proj, mul(camera.view, mul(camera.model, position)));
-    output.vertexColor = vertexColors[vertexId];
+    output.vertexColor = color;
     return output;
 }
 

MiscData.cpp

@@ -6,16 +6,21 @@
 #include "MacroUtils.h"
 #include "RenderDevice.h"
 
+#include <glm/gtc/matrix_transform.hpp>
 
 void MiscData::init( RenderDevice const& renderDevice )
 {
   VkDevice const device = renderDevice.device;
+
+  previousCounter = 0;
+
+  // Pipeline Creation
   {
     size_t dataSize;
-		void* rawData = SDL_LoadFile("Triangle.spv", &dataSize);
+    void*  rawData = SDL_LoadFile( "Mesh.spv", &dataSize );
     ASSERT( dataSize % 4 == 0 );
 
-		if (not rawData)
+    if ( !rawData )
     {
       SDL_LogError( SDL_LOG_CATEGORY_SYSTEM, "%s", SDL_GetError() );
       abort();
@@ -34,12 +39,29 @@ void MiscData::init(RenderDevice const& renderDevice)
     VkShaderModule shaderModule;
     VK_CHECK( vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule) );
 
-		VkPipelineLayoutCreateInfo constexpr pipelineLayoutCreateInfo = {
+    VkDescriptorSetLayoutBinding constexpr descriptorSetLayoutBinding = {
+      .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 = 0,
+      .setLayoutCount = 1,
-			.pSetLayouts = nullptr,
+      .pSetLayouts = &descriptorSetLayout,
       .pushConstantRangeCount = 0,
       .pPushConstantRanges = nullptr,
     };
@@ -66,21 +88,42 @@ void MiscData::init(RenderDevice const& renderDevice)
       }
     };
 
-		VkPipelineVertexInputStateCreateInfo constexpr vertexInputState = {
+    VkVertexInputBindingDescription constexpr bindingDescription = {
+      .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 = 0,
+      .vertexBindingDescriptionCount = 1,
-			.pVertexBindingDescriptions = nullptr,
+      .pVertexBindingDescriptions = &bindingDescription,
-			.vertexAttributeDescriptionCount = 0,
+      .vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size()),
-			.pVertexAttributeDescriptions = nullptr,
+      .pVertexAttributeDescriptions = attributeDescriptions.data(),
     };
 
     VkPipelineInputAssemblyStateCreateInfo constexpr inputAssembly = {
       .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
       .pNext = nullptr,
       .flags = 0,
-			.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
+      .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
       .primitiveRestartEnable = VK_FALSE,
     };
 
@@ -210,13 +253,191 @@ void MiscData::init(RenderDevice const& renderDevice)
       .basePipelineIndex = 0,
     };
 
-		VK_CHECK(vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &trianglePipeline));
+    VK_CHECK( vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &meshPipeline) );
 
     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,
@@ -279,11 +500,17 @@ void MiscData::init(RenderDevice const& renderDevice)
       .pImageMemoryBarriers = &renderToPresentBarrier,
     };
   }
+}
 
-void MiscData::cleanup(RenderDevice const& renderDevice)
+void MiscData::destroy( RenderDevice const& renderDevice )
 {
   VkDevice const device = renderDevice.device;
 
-	vkDestroyPipeline(device, trianglePipeline, nullptr);
+  vkDestroyDescriptorPool( device, Take( descriptorPool ), nullptr );
-	vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
+  vmaDestroyBuffer( renderDevice.gpuAllocator, Take( cameraUniformBuffer ), Take( cameraUniformBufferAllocation ) );
+  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,13 +1,49 @@
 #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 trianglePipeline;
+  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;
@@ -15,5 +51,5 @@ struct MiscData
   VkDependencyInfo      renderToPresentDependency;
 
   void init( RenderDevice const& renderDevice );
-	void cleanup(RenderDevice const& renderDevice);
+  void destroy( RenderDevice const& renderDevice );
 };

RenderDevice.cpp

@@ -62,7 +62,7 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
   VkPhysicalDevice        physicalDeviceInUse    = nullptr;
   VkDevice                device                 = nullptr;
   VmaAllocator            gpuAllocator           = nullptr;
-	std::optional<uint32_t> directQueueFamilyIndex;
+  std::optional<uint32_t> directQueueFamilyIndex = std::nullopt;
   VkQueue                 directQueue            = nullptr;
   // Create Device and Queue
   {
@@ -72,7 +72,8 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
     VK_CHECK( vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr) );
     SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "Found %u GPUs", physicalDeviceCount );
 
-		VkPhysicalDevice* physicalDevices = reinterpret_cast<VkPhysicalDevice*>(mem->allocate(sizeof(VkPhysicalDevice) * physicalDeviceCount));
+    VkPhysicalDevice* physicalDevices = reinterpret_cast<VkPhysicalDevice*>(mem->allocate(
+      sizeof( VkPhysicalDevice ) * physicalDeviceCount ));
     VK_CHECK( vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices) );
 
     for ( VkPhysicalDevice const physicalDevice : std::span{ physicalDevices, physicalDeviceCount } )
@@ -84,7 +85,9 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
 
       SDL_LogInfo( SDL_LOG_CATEGORY_GPU, "GPU: %s", properties.deviceName );
 
-			SDL_LogInfo(SDL_LOG_CATEGORY_GPU, "- API Version %d.%d.%d",
+      SDL_LogInfo(
+        SDL_LOG_CATEGORY_GPU,
+        "- API Version %d.%d.%d",
         VK_API_VERSION_MAJOR( properties.apiVersion ),
         VK_API_VERSION_MINOR( properties.apiVersion ),
         VK_API_VERSION_PATCH( properties.apiVersion ) );
@@ -102,7 +105,8 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
 
       uint32_t queueFamilyCount;
       vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, nullptr );
-			VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast<VkQueueFamilyProperties*>(mem->allocate(sizeof(VkQueueFamilyProperties) * queueFamilyCount));
+      VkQueueFamilyProperties* queueFamilyProperties = reinterpret_cast<VkQueueFamilyProperties*>(mem->allocate(
+        sizeof( VkQueueFamilyProperties ) * queueFamilyCount ));
       vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, queueFamilyProperties );
 
       for ( uint32_t queueFamilyIndex = 0; queueFamilyIndex != queueFamilyCount;
@@ -133,7 +137,8 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
         }
 
         VkBool32 isSurfaceSupported;
-				VK_CHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported));
+        VK_CHECK(
+          vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, &isSurfaceSupported) );
 
         if ( isSurfaceSupported )
         {
@@ -147,7 +152,6 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
           directQueueFamilyIndex = queueFamilyIndex;
           break;
         }
-
       }
 
       mem->restoreState( tempAllocQueueProperties );
@@ -254,7 +258,8 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
 
     uint32_t surfaceFormatCount;
     vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, nullptr );
-		VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(sizeof(VkSurfaceFormatKHR*) * surfaceFormatCount));
+    VkSurfaceFormatKHR* surfaceFormats = reinterpret_cast<VkSurfaceFormatKHR*>(mem->allocate(
+      sizeof( VkSurfaceFormatKHR ) * surfaceFormatCount ));
     vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDeviceInUse, surface, &surfaceFormatCount, surfaceFormats );
 
     VkSurfaceFormatKHR format = {
@@ -266,15 +271,18 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
       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) {
+        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;
         }
       }
@@ -284,7 +292,8 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
 
     uint32_t presentModeCount;
     vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, nullptr );
-		VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(sizeof(VkPresentModeKHR*) * presentModeCount));
+    VkPresentModeKHR* presentModes = reinterpret_cast<VkPresentModeKHR*>(mem->allocate(
+      sizeof( VkPresentModeKHR ) * presentModeCount ));
     vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDeviceInUse, surface, &presentModeCount, presentModes );
 
     VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
@@ -333,7 +342,8 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
     vkGetSwapchainImagesKHR( device, swapchain, &swapchainImageCount, swapchainImages );
 
     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,
@@ -370,9 +380,20 @@ RenderDevice* CreateRenderDevice(GlobalMemory* mem, RenderDevice::CreateInfo con
 
   Byte* allocation = mem->allocate( sizeof( RenderDevice ), alignof( RenderDevice ) );
   return new( allocation ) RenderDevice{
-		instance, surface, physicalDeviceInUse,
+    instance,
-		device, gpuAllocator, directQueue, directQueueFamilyIndex.value(),
+    surface,
-		swapchainFormat, swapchainExtent, swapchain, swapchainImages, swapchainViews, frames, swapchainImageCount,
+    physicalDeviceInUse,
+    device,
+    gpuAllocator,
+    directQueue,
+    directQueueFamilyIndex.value(),
+    swapchainFormat,
+    swapchainExtent,
+    swapchain,
+    swapchainImages,
+    swapchainViews,
+    frames,
+    swapchainImageCount,
   };
 }
 
@@ -381,14 +402,13 @@ inline bool RenderDevice::isInit() const
   return instance and device;
 }
 
-void RenderDevice::cleanup()
+void RenderDevice::destroy()
 {
-	if (not isInit())
+  if ( not isInit() ) return;
-		return;
 
   for ( Frame& frame : std::span{ frames, swapchainImageCount } )
   {
-		frame.cleanup(*this);
+    frame.destroy( *this );
   }
 
   for ( auto const& view : std::span{ swapchainViews, swapchainImageCount } )
@@ -398,6 +418,7 @@ void RenderDevice::cleanup()
 
   vkDestroySwapchainKHR( device, Take( swapchain ), nullptr );
 
+  vmaDestroyAllocator( Take( gpuAllocator ) );
   vkDestroyDevice( Take( device ), nullptr );
 
   SDL_Vulkan_DestroySurface( instance, Take( surface ), nullptr );
@@ -417,10 +438,21 @@ uint32_t RenderDevice::getNumFrames() const
   return swapchainImageCount;
 }
 
-RenderDevice::RenderDevice(VkInstance const instance, VkSurfaceKHR const surface, VkPhysicalDevice const physicalDeviceInUse,
+RenderDevice::RenderDevice(
-	VkDevice const device, VmaAllocator gpuAllocator, VkQueue const directQueue, uint32_t const directQueueFamilyIndex,
+  VkInstance const       instance,
-	VkFormat const swapchainFormat, VkExtent2D const swapchainExtent, VkSwapchainKHR const swapchain, VkImage* swapchainImages,
+  VkSurfaceKHR const     surface,
-	VkImageView* swapchainViews, Frame* frames, uint32_t const swapchainImageCount)
+  VkPhysicalDevice const physicalDeviceInUse,
+  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 }
@@ -434,6 +466,4 @@ RenderDevice::RenderDevice(VkInstance const instance, VkSurfaceKHR const surface
   , 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 cleanup();
+  void                   destroy();
   void                   waitIdle() const;
   [[nodiscard]] uint32_t getNumFrames() const;
 

vcpkg.json

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