Initial mesh_shaders sample commit

Reviewed-on: #1

.vscode/launch.json

@@ -8,7 +8,7 @@
             "preLaunchTask": "Build",
             "expressions": "native",
             "cwd": "${workspaceFolder}",
-            "program": "${workspaceFolder}/build/evk"
+            "program": "${workspaceFolder}/build/samples/descriptor_heap/descriptor_heap"
         }
     ]
-}
+}

.vscode/tasks.json

@@ -23,7 +23,7 @@
         {
             "label": "Run",
             "type": "shell",
-            "command": "./build/evk",
+            "command": "./build/samples/descriptor_heap/descriptor_heap",
             "windows": {
               "command": "build/evk.exe"
             },
@@ -37,4 +37,4 @@
           "dependsOrder": "sequence"
         }
     ]
-}
+}

evk/evkBuffer.c

@@ -18,11 +18,11 @@ evkBuffer evkCreateBuffer(evkDevice* device, evkBufferCreateInfo createInfo)
 
   if(buffer.vk != VK_NULL_HANDLE)
   {
-    buffer.sizeInBytes = createInfo.sizeInBytes;
+    buffer.addressRange.address = vkGetBufferDeviceAddressKHR(device->vk, &(VkBufferDeviceAddressInfo){
-    buffer.address = vkGetBufferDeviceAddressKHR(device->vk, &(VkBufferDeviceAddressInfo){
+      .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
-      .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, 
       .buffer = buffer.vk
     });
+    buffer.addressRange.size = createInfo.sizeInBytes;
   }
 
   return buffer;
@@ -31,4 +31,4 @@ evkBuffer evkCreateBuffer(evkDevice* device, evkBufferCreateInfo createInfo)
 void evkDestroyBuffer(evkBuffer buf)
 {
   evkGPUDestroyBuffer(buf);
-}
+}

evk/evkCommon.h

@@ -88,9 +88,9 @@ static inline const char* VkResultStrings(VkResult res) {
   }
 };
 
-#define EVK_ASSERT(fn) do { \
+static VkResult __evk_check_result_internal;
-  VkResult __vk_assert_result_internal = fn; \
+#define EVK_CHECK(fn) (                                                                                                                                                \
-  if(__vk_assert_result_internal != VK_SUCCESS) { \
+    __evk_check_result_internal = fn,                                                                                                                                  \
-    ev_log_error("[VulkanError] `%s` returned error code %d ('%s')", EV_STRINGIZE(fn), __vk_assert_result_internal, VkResultStrings(__vk_assert_result_internal));\
+    __evk_check_result_internal != VK_SUCCESS?                                                                                                                         \
-  } \
+      ev_log_error("[VulkanError] `%s` returned error code %d ('%s')", EV_STRINGIZE(fn), __evk_check_result_internal, VkResultStrings(__evk_check_result_internal)):0, \
-} while (0)
+    __evk_check_result_internal)

evk/evkDescriptor.c

@@ -137,8 +137,8 @@ void evkSetDescriptor(evkDescriptorSet* set, evstring name, evkBuffer* buf)
 
   VkDescriptorAddressInfoEXT addressInfo = {
     VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT,
-    .address = buf->address,
+    .address = buf->addressRange.address,
-    .range = buf->sizeInBytes,
+    .range = buf->addressRange.size,
     .format = VK_FORMAT_UNDEFINED,
   };
 
@@ -168,7 +168,7 @@ void evkCmdBindDescriptorSets(evkCommandBuffer* cmdbuf, evkPipeline* pipeline, v
   {
     bindingInfos[i] = (VkDescriptorBufferBindingInfoEXT) {
       .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
-      .address = sets[setIndices[i]].buffer.address,
+      .address = sets[setIndices[i]].buffer.addressRange.address,
       .usage = sets[setIndices[i]].buffer.usage,
     };
     setOffsets[i] = offset;
@@ -177,10 +177,10 @@ void evkCmdBindDescriptorSets(evkCommandBuffer* cmdbuf, evkPipeline* pipeline, v
 
   vkCmdBindDescriptorBuffersEXT(cmdbuf->vk, bindingCount, bindingInfos);
 
-  vkCmdSetDescriptorBufferOffsetsEXT(cmdbuf->vk, 
+  vkCmdSetDescriptorBufferOffsetsEXT(cmdbuf->vk,
-      (VkPipelineBindPoint)pipeline->type, 
+      (VkPipelineBindPoint)pipeline->type,
-      pipeline->layout.vk, 
+      pipeline->layout.vk,
-      0, bindingCount, 
+      0, bindingCount,
-      actualSetIndices, 
+      actualSetIndices,
       setOffsets);
-}
+}

evk/evkDevice.c

@@ -27,6 +27,25 @@ VkPhysicalDeviceDescriptorBufferFeaturesEXT descriptorBufFeature = {
   // )
 };
 
+VkPhysicalDeviceDescriptorHeapFeaturesEXT descriptorHeapFeature = {
+  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT,
+  .descriptorHeap = VK_TRUE,
+
+  EV_DEBUG(
+    .descriptorHeapCaptureReplay = VK_TRUE,
+  )
+};
+
+VkPhysicalDeviceShaderUntypedPointersFeaturesKHR shaderUntypedPointersFeature = {
+  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR,
+  .shaderUntypedPointers = VK_TRUE,
+};
+
+VkPhysicalDeviceShaderObjectFeaturesEXT shaderObjectFeature = {
+  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT,
+  .shaderObject = VK_TRUE,
+};
+
 typedef struct {
   evstring name;
   void* data;
@@ -34,7 +53,10 @@ typedef struct {
 } evkDeviceExtension;
 
 const evkDeviceExtension evkSupportedExtensions[] = {
-  { evstr(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)    , &descriptorBufFeature   , &descriptorBufFeature.pNext },
+  { evstr(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME)      , &descriptorBufFeature        , &descriptorBufFeature.pNext },
+  { evstr(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME)        , &descriptorHeapFeature       , &descriptorHeapFeature.pNext },
+  { evstr(VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME), &shaderUntypedPointersFeature, &shaderUntypedPointersFeature.pNext },
+  { evstr(VK_EXT_SHADER_OBJECT_EXTENSION_NAME)          , &shaderObjectFeature         , &shaderObjectFeature.pNext },
 };
 const u32 evkSupportedExtensionsCount = EV_ARRSIZE(evkSupportedExtensions);
 
@@ -71,7 +93,7 @@ evkDevice evkCreateDevice(evkDeviceCreateInfo createInfo)
   device._physicalDevice = evkDetectPhysicalDevice(createInfo.instance, createInfo.physicalDeviceType);
   device._instance = createInfo.instance;
 
-  VkPhysicalDeviceProperties2 physicalDeviceProperties = { 
+  VkPhysicalDeviceProperties2 physicalDeviceProperties = {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
   };
 
@@ -200,7 +222,7 @@ evkDevice evkCreateDevice(evkDeviceCreateInfo createInfo)
 	}
 
 	// Allowing the retrieval of non-requested, but allocated, queues is possible.
-	// Example: Allocating COMPUTE | GRAPHICS then requesting GRAPHICS should 
+	// Example: Allocating COMPUTE | GRAPHICS then requesting GRAPHICS should
 	// return the already allocated queue
 	for (i32 i = MAX_QUEUE_FAMILIES - 1; i >= 0; i--) {
 		for (i32 j = i - 1; j >= 0; j--) {
@@ -210,7 +232,7 @@ evkDevice evkCreateDevice(evkDeviceCreateInfo createInfo)
 		}
 	}
 
-	EVK_ASSERT(vkCreateDevice(device._physicalDevice, &vkDeviceCreateInfo, evkGetAllocationCallbacks(), &device.vk));
+	EVK_CHECK(vkCreateDevice(device._physicalDevice, &vkDeviceCreateInfo, evkGetAllocationCallbacks(), &device.vk));
 
 	vec_fini(&queueCreateInfoList);
   vec_fini(&priorities);
@@ -221,4 +243,4 @@ evkDevice evkCreateDevice(evkDeviceCreateInfo createInfo)
 void evkDestroyDevice(evkDevice device)
 {
   vkDestroyDevice(device.vk, evkGetAllocationCallbacks());
-}
+}

evk/evkMemory.c

@@ -56,6 +56,7 @@ evkImage evkGPUCreateImage(evkGPUAllocationCreateInfo allocationCreateInfo, VkIm
     .flags = allocationCreateInfo.allocationFlags,
     .pool = allocationCreateInfo.pool.vma,
   };
+  img.allocData.allocator = allocationCreateInfo.allocator;
 
   vmaCreateImage(allocationCreateInfo.allocator.vma, imageCreateInfo, &vmaAllocCreateInfo, &img.vk, &img.allocData.allocation.vma, &img.allocData.allocationInfo.vma);
 
@@ -79,6 +80,7 @@ evkBuffer evkGPUCreateBuffer(evkGPUAllocationCreateInfo allocationCreateInfo, Vk
 
   vmaCreateBuffer(allocationCreateInfo.allocator.vma, bufferCreateInfo, &vmaAllocCreateInfo, &buf.vk, &buf.allocData.allocation.vma, &buf.allocData.allocationInfo.vma);
   buf.usage = bufferCreateInfo->usage;
+  buf.allocData.allocator = allocationCreateInfo.allocator;
 
   return buf;
 }
@@ -86,4 +88,4 @@ evkBuffer evkGPUCreateBuffer(evkGPUAllocationCreateInfo allocationCreateInfo, Vk
 void evkGPUDestroyBuffer(evkBuffer buf)
 {
   vmaDestroyBuffer(buf.allocData.allocator.vma, buf.vk, buf.allocData.allocation.vma);
-}
+}

evk/evkPipeline.c

@@ -59,8 +59,14 @@ evkPipeline evkCreateGraphicsPipeline(evkDevice device, evkPipelineCreateInfo cr
   for(int i = 0; i < colorAttachmentCount; i++)
     colorAttachmentFormats[i] = createInfo.colorAttachments[i].format;
 
+  VkPipelineCreateFlags2CreateInfo pipelineCreateFlags2CreateInfo = {
+    .sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO,
+    .flags = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT,
+  };
+
   VkPipelineRenderingCreateInfoKHR pipelineRenderingCreateInfo = {
       .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
+      .pNext = &pipelineCreateFlags2CreateInfo,
       .colorAttachmentCount = colorAttachmentCount,
       .pColorAttachmentFormats = colorAttachmentFormats,
       .depthAttachmentFormat = createInfo.depthAttachmentFormat,
@@ -183,7 +189,7 @@ evkPipeline evkCreateGraphicsPipeline(evkDevice device, evkPipelineCreateInfo cr
 
   if(createInfo.setLayouts != NULL)
   {
-    res.layout = evkCreatePipelineLayout(device, 
+    res.layout = evkCreatePipelineLayout(device,
       EV_DEFAULT(evkPipelineLayoutCreateInfo,
         setLayouts = createInfo.setLayouts,
       )
@@ -191,13 +197,13 @@ evkPipeline evkCreateGraphicsPipeline(evkDevice device, evkPipelineCreateInfo cr
   }
   else
   {
-    assert(!"Set Layout construction through shader reflection not implemented yet.");
+    // assert(!"Set Layout construction through shader reflection not implemented yet.");
   }
 
   VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo = {
     .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
     .pNext = &pipelineRenderingCreateInfo,
-    .flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT,
+    .flags = 0,
     .stageCount = shaderStageCount,
     .pStages = shaderStageCreateInfos,
     .pVertexInputState = &vertexInputStateCreateInfo,
@@ -210,7 +216,9 @@ evkPipeline evkCreateGraphicsPipeline(evkDevice device, evkPipelineCreateInfo cr
     .layout = res.layout.vk,
   };
 
-  EVK_ASSERT(vkCreateGraphicsPipelines(device.vk, VK_NULL_HANDLE, 1, &graphicsPipelineCreateInfo, NULL, &res.vk));
+
+
+  EVK_CHECK(vkCreateGraphicsPipelines(device.vk, VK_NULL_HANDLE, 1, &graphicsPipelineCreateInfo, NULL, &res.vk));
 
   res._device = device;
 
@@ -243,4 +251,4 @@ void evkCmdBindPipeline(evkCommandBuffer* cmdbuf, evkPipeline* pipeline)
 void evkCmdImageBarrier(evkCommandBuffer* cmdbuf, VkImageMemoryBarrier barrier)
 {
     vkCmdPipelineBarrier(cmdbuf->vk, 0, 0, 0, 0, NULL, 0, NULL, 1, &barrier);
-}
+}

evk/evkShader.c

@@ -13,7 +13,7 @@ evkShader evkInitShaderFromBytes(evkDevice device, const u8* shaderBytes, u32 sh
   };
   vkCreateShaderModule(device.vk, &createInfo, NULL, &shader.vk);
 
-  shader.reflect = evkGenerateShaderReflectionData(shaderBytes, shaderLen);
+  // shader.reflect = evkGenerateShaderReflectionData(shaderBytes, shaderLen);
 
   return shader;
 }
@@ -96,6 +96,7 @@ evkShaderCompiler evkCreateShaderCompiler()
   evkShaderCompiler compiler;
   compiler.sc = shaderc_compiler_initialize();
   compiler.scopt = shaderc_compile_options_initialize();
+  shaderc_compile_options_set_target_spirv(compiler.scopt, shaderc_spirv_version_1_3);
   shaderc_compile_options_set_include_callbacks(compiler.scopt, _shader_include_resolve, _shader_include_release, NULL);
   shaderc_compile_options_set_generate_debug_info(compiler.scopt);
   return compiler;
@@ -107,27 +108,28 @@ void evkDestroyShaderCompiler(evkShaderCompiler compiler)
   shaderc_compiler_release(compiler.sc);
 }
 
-evkShader evkInitShaderFromFile(evkDevice device, evkShaderCompiler compiler, evstring shaderPath)
+evkShader evkInitShaderFromString(evkDevice device, evkShaderCompiler compiler,evstring shaderName, evstring shaderText, VkShaderStageFlags stage)
 {
-  evstring shaderText = evstring_readFile(shaderPath);
+  shaderc_compilation_result_t compilation_result = shaderc_compile_into_spv(compiler.sc, shaderText, evstring_getLength(shaderText), shaderc_glsl_infer_from_source, shaderName, "main", compiler.scopt);
-
-  shaderc_compilation_result_t compilation_result = shaderc_compile_into_spv(compiler.sc, shaderText, evstring_getLength(shaderText), shaderc_glsl_infer_from_source, shaderPath, "main", compiler.scopt);
 
   shaderc_compilation_status status = shaderc_result_get_compilation_status(compilation_result);
 
   u32 errorCount = shaderc_result_get_num_errors(compilation_result);
   u32 warnCount = shaderc_result_get_num_warnings(compilation_result);
-  ev_log_info("[[evkShader]] %s Compilation Status: %d ( %d Errors, %d Warnings )", shaderPath, status, errorCount, warnCount);
+  ev_log_info("[[evkShader]] %s Compilation Status: %d ( %d Errors, %d Warnings )", shaderName, status, errorCount, warnCount);
   if(errorCount + warnCount > 0)
   {
     ev_log_error("Errors:\n%s", shaderc_result_get_error_message(compilation_result));
   }
 
-  evkShader shader = evkInitShaderFromBytes(device, (u8*)shaderc_result_get_bytes(compilation_result), shaderc_result_get_length(compilation_result));
+  evkShader res = evkInitShaderFromBytes(device, (u8*)shaderc_result_get_bytes(compilation_result), shaderc_result_get_length(compilation_result));
-
+  res.reflect.stage = stage;
-  evstring_free(shaderText);
+  return res;
-
+}
-  return shader;
+evkShader evkInitShaderFromFile(evkDevice device, evkShaderCompiler compiler, evstring shaderPath)
+{
+  evstring shaderText = evstring_readFile(shaderPath);
+  return evkInitShaderFromString(device, compiler, shaderPath, shaderText, 0);
 }
 
 VkPipelineShaderStageCreateInfo evkGetShaderStageCreateInfo(evkShader shader)
@@ -138,4 +140,4 @@ VkPipelineShaderStageCreateInfo evkGetShaderStageCreateInfo(evkShader shader)
     .module = shader.vk,
     .pName = "main",
   };
-}
+}

evk/evkShader.h

@@ -4,6 +4,9 @@
 
 [[nodiscard("Leaking VkShaderModule")]]
 evkShader evkInitShaderFromBytes(evkDevice device, const u8* shaderBytes, u32 shaderLen);
+[[nodiscard("Leaking VkShaderModule")]]
+evkShader evkInitShaderFromString(evkDevice device, evkShaderCompiler compiler, evstring shaderName, evstring shaderText, VkShaderStageFlags stage);
+[[nodiscard("Leaking VkShaderModule")]]
 evkShader evkInitShaderFromFile(evkDevice device, evkShaderCompiler compiler, evstring shaderPath);
 void evkDestroyShader(evkDevice device, evkShader shader);
 
@@ -15,4 +18,4 @@ VkPipelineShaderStageCreateInfo evkGetShaderStageCreateInfo(evkShader shader);
 
 [[nodiscard("Leaking Shader Reflection Data")]]
 evkShaderReflectionData evkGenerateShaderReflectionData(const u8* shaderBytes, u32 shaderLen);
-void evkDestroyShaderReflectionData(evkShaderReflectionData data);
+void evkDestroyShaderReflectionData(evkShaderReflectionData data);

evk/evkSwapChain.c

@@ -9,7 +9,7 @@ evkSwapChain evkCreateSwapChain(evkSwapChainCreateInfo createInfo)
   VkSurfaceCapabilitiesKHR surfaceCaps;
   vkGetPhysicalDeviceSurfaceCapabilitiesKHR(createInfo.device._physicalDevice, createInfo.surface, &surfaceCaps);
 
-  if(surfaceCaps.maxImageCount == 0) 
+  if(surfaceCaps.maxImageCount == 0)
     surfaceCaps.maxImageCount = UInt32.MAX;
 
   VkCompositeAlphaFlagBitsKHR compositeAlpha =
@@ -27,7 +27,7 @@ evkSwapChain evkCreateSwapChain(evkSwapChainCreateInfo createInfo)
   VkSurfaceFormatKHR surfaceFormats[surfaceFormatCount];
   vkGetPhysicalDeviceSurfaceFormatsKHR(createInfo.device._physicalDevice, createInfo.surface, &surfaceFormatCount, surfaceFormats);
 
-  // TODO Add format picking logic 
+  // TODO Add format picking logic
   swapChain.surfaceFormat = surfaceFormats[0];
 
   u32 buffering = min(max(createInfo.imageCount, surfaceCaps.minImageCount), surfaceCaps.maxImageCount);
@@ -56,7 +56,7 @@ evkSwapChain evkCreateSwapChain(evkSwapChainCreateInfo createInfo)
     .oldSwapchain = VK_NULL_HANDLE,
   };
 
-  EVK_ASSERT(vkCreateSwapchainKHR(createInfo.device.vk, &swapChainCreateInfo, NULL, &swapChain.vk));
+  EVK_CHECK(vkCreateSwapchainKHR(createInfo.device.vk, &swapChainCreateInfo, NULL, &swapChain.vk));
 
   vkGetSwapchainImagesKHR(createInfo.device.vk, swapChain.vk, &buffering, NULL);
   VkImage swapChainVkImages[buffering];
@@ -69,9 +69,9 @@ evkSwapChain evkCreateSwapChain(evkSwapChainCreateInfo createInfo)
   for(u32 i = 0; i < buffering; i++)
   {
     swapChain.images[i] = (evkImage) {
-      .vk = swapChainVkImages[i], 
+      .vk = swapChainVkImages[i],
-      .width = imageExtent.width, 
+      .width = imageExtent.width,
-      .height = imageExtent.height, 
+      .height = imageExtent.height,
       .format = swapChain.surfaceFormat.format
     };
     swapChain.imageViews[i] = evkCreateImageView(createInfo.device, swapChain.images[i],
@@ -94,4 +94,4 @@ void evkDestroySwapChain(evkDevice device, evkSwapChain swapChain)
   vec_fini(&swapChain.imageViews);
   vec_fini(&swapChain.images);
   vkDestroySwapchainKHR(device.vk, swapChain.vk, NULL);
-}
+}

evk/evkTypes.h

@@ -26,7 +26,7 @@ TYPEDATA_GEN(VkRenderingAttachmentInfoKHR,
       .clearValue = (VkClearValue){{{0.f, 0.f, 0.f, 1.f}}},
     )
 );
-TYPEDATA_GEN(VkViewport, 
+TYPEDATA_GEN(VkViewport,
   DEFAULT(
     .x = 0,
     .y = 0,
@@ -65,11 +65,11 @@ TYPEDATA_GEN(VkImageMemoryBarrier,
   )
 )
 
-TYPEDATA_GEN(VkRect2D, 
+TYPEDATA_GEN(VkRect2D,
   DEFAULT(0)
 )
 
-TYPEDATA_GEN(VkRenderingInfo, 
+TYPEDATA_GEN(VkRenderingInfo,
   DEFAULT(
     .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
     .flags = 0,
@@ -365,9 +365,8 @@ typedef struct {
 typedef struct {
   VkBuffer vk;
   evkGPUAllocationData allocData;
-  u32 sizeInBytes;
   VkBufferUsageFlags usage;
-  VkDeviceAddress address;
+  VkDeviceAddressRangeEXT addressRange;
 } evkBuffer;
 
 typedef struct {
@@ -522,7 +521,7 @@ typedef struct {
   evkPipeline* boundPipeline;
 } evkCommandBuffer;
 
-TYPEDATA_GEN(evkInstance, 
+TYPEDATA_GEN(evkInstance,
   INVALID(
     .vk = VK_NULL_HANDLE,
   )
@@ -561,7 +560,7 @@ TYPEDATA_GEN(evkImageViewCreateInfo,
 TYPEDATA_GEN(evkAllocationUserData, INVALID(__EV_VEC_EMPTY_ARRAY));
 TYPEDATA_GEN(evkDeviceQueueRequirement);
 
-TYPEDATA_GEN(evkViewport, 
+TYPEDATA_GEN(evkViewport,
   DEFAULT(
     .x = 0,
     .y = 0,
@@ -578,7 +577,7 @@ TYPEDATA_GEN(evkViewport,
 
 TYPEDATA_GEN(evkColorAttachment);
 
-TYPEDATA_GEN(evkPipelineCreateInfo, 
+TYPEDATA_GEN(evkPipelineCreateInfo,
   DEFAULT(
     .type = EVK_PIPELINE_TYPE_GRAPHICS,
     .dynamicStates = EV_VEC_EMPTY,
@@ -598,4 +597,4 @@ TYPEDATA_GEN(evkDescriptorBinding);
 TYPEDATA_GEN(evkDescriptorSetLayout);
 TYPEDATA_GEN(evkDescriptorSet);
 
-TYPEDATA_GEN(evkCommandBuffer);
+TYPEDATA_GEN(evkCommandBuffer);

meson.build

@@ -31,8 +31,8 @@ disabled_warnings = {
 }
 
 subproject('evol-headers', default_options: {'build_tests': false})
-subproject('volk')
+# subproject('volk')
-subproject('shaderc')
+# subproject('shaderc')
 
 evk_c_args = []
 

samples/basic_triangle/basic_triangle.c

@@ -8,7 +8,16 @@
 
 evstring PROJECT_NAME = evstr("basic_triangle");
 
-int main(void) 
+char vertexShaderBytes[] = {
+#embed "shaders/basic_triangle.vert"
+  ,'\0'
+};
+char fragmentShaderBytes[] = {
+#embed "shaders/basic_triangle.frag"
+  ,'\0'
+};
+
+int main(void)
 {
   u32 width = 1280;
   u32 height = 800;
@@ -82,7 +91,7 @@ int main(void)
   }
 
   VkSurfaceKHR surface;
-  VkResult err = glfwCreateWindowSurface(instance.vk, window, NULL, &surface);
+  VkResult err = EVK_CHECK(glfwCreateWindowSurface(instance.vk, window, NULL, &surface));
   if (err)
   {
     ev_log_error("Surface creation failed.");
@@ -99,8 +108,8 @@ int main(void)
     .imageCount = 3,
   });
 
-  evkCommandPool commandPool = evkCreateCommandPool((evkCommandPoolCreateInfo) { 
+  evkCommandPool commandPool = evkCreateCommandPool((evkCommandPoolCreateInfo) {
-    .device = device, 
+    .device = device,
     .queueFlags = VK_QUEUE_GRAPHICS_BIT,
     .poolFlags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
   });
@@ -109,9 +118,15 @@ int main(void)
 
   evkShaderCompiler compiler = evkCreateShaderCompiler();
 
-  evkShader vertShader = evkInitShaderFromFile(device, compiler, "shaders/basic_triangle.vert");
+  evstring vertexShaderText = evstring_new(vertexShaderBytes);
-  evkShader fragShader = evkInitShaderFromFile(device, compiler, "shaders/basic_triangle.frag");
+  evstring fragmentShaderText = evstring_new(fragmentShaderBytes);
-  
+
+  evkShader vertShader = evkInitShaderFromString(device, compiler, evstr("basic_triangle.vert"),vertexShaderText);
+  evkShader fragShader = evkInitShaderFromString(device, compiler, evstr("basic_triangle.frag"), fragmentShaderText);
+
+  evstring_free(vertexShaderText);
+  evstring_free(fragmentShaderText);
+
   evkDestroyShaderCompiler(compiler);
 
   evkColorAttachment colorAttachment0 = {
@@ -122,25 +137,26 @@ int main(void)
   // TODO Get this from shader reflection data
   // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayout(
   //   &device, svec_init(evkDescriptorBinding, {
-  //     { 
+  //     {
-  //       .name = evstr("positions"), 
+  //       .name = evstr("positions"),
-  //       .binding = 0, 
+  //       .binding = 0,
-  //       .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 
+  //       .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-  //       .descriptorCount = 1, 
+  //       .descriptorCount = 1,
-  //       .stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS, 
+  //       .stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS,
   //     },
   //   })
   // );
   // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayoutFromBindings(&device, vertShader.reflect.bindings);
+
   evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayoutFromShaders(&device, svec_init(evkShader, {vertShader, fragShader}));
 
   evkPipelineCreateInfo pipelineCreateInfo = EV_DEFAULT(evkPipelineCreateInfo,
-    dynamicStates = svec_init(VkDynamicState, { 
+    dynamicStates = svec_init(VkDynamicState, {
-      VK_DYNAMIC_STATE_VIEWPORT, 
+      VK_DYNAMIC_STATE_VIEWPORT,
       VK_DYNAMIC_STATE_SCISSOR,
     }),
     shaderStages = svec_init(evkShader, {
-      vertShader, 
+      vertShader,
       fragShader,
     }),
     colorAttachments = svec_init(evkColorAttachment, {
@@ -158,8 +174,8 @@ int main(void)
   );
 
   evkDescriptorSet set_0 = evkCreateDescriptorSet(&(evkDescriptorSetCreateInfo){
-    .device = &device, 
+    .device = &device,
-    .allocator = &allocator, 
+    .allocator = &allocator,
     .layout = &setLayout_0
   });
 
@@ -228,7 +244,7 @@ int main(void)
   {
     imageIdx = (imageIdx + 1) % imageCount;
     u32 swapChainImageIdx;
-    EVK_ASSERT(vkAcquireNextImageKHR(device.vk, swapChain.vk, UInt64.MAX, imageAcquiredSemaphores[imageIdx], VK_NULL_HANDLE, &swapChainImageIdx));
+    EVK_CHECK(vkAcquireNextImageKHR(device.vk, swapChain.vk, UInt64.MAX, imageAcquiredSemaphores[imageIdx], VK_NULL_HANDLE, &swapChainImageIdx));
 
     evkCommandBuffer cmdbuf = commandBuffers[imageIdx];
 
@@ -269,6 +285,7 @@ int main(void)
 
       evkCmdImageBarrier(&cmdbuf, EV_DEFAULT(VkImageMemoryBarrier,
         image = swapChain.images[swapChainImageIdx].vk,
+        oldLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
         newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
         subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT
       ));
@@ -321,6 +338,9 @@ int main(void)
 
   evkDestroyPipeline(graphicsPipeline);
 
+  evkDestroyBuffer(vertBuf);
+  evkDestroyBuffer(uniBuf);
+
   evkDestroyDescriptorSet(&device, &set_0);
   evkDestroyDescriptorSetLayout(&device, &setLayout_0);
 
@@ -330,6 +350,8 @@ int main(void)
   evkFreeCommandBuffers(device, commandPool, commandBuffers);
   evkDestroyCommandPool(device, commandPool);
 
+  evkGPUDestroyAllocator(allocator);
+
   evkDestroySwapChain(device, swapChain);
 
 // SwapchainCreationFailed:
@@ -346,4 +368,4 @@ DeviceCreationFailed:
   evkDestroyInstance(instance);
 InstanceCreationFailed:
   return 0;
-}
+}

samples/basic_triangle/shaders/basic_triangle.vert

@@ -1,7 +1,7 @@
 #version 450
 #pragma shader_stage(vertex)
 
-// in layout(location=0) vec2 position;
+in layout(location=0) vec2 position;
 
 layout(set=0, binding=0) uniform data {
   vec4 positions[3];
@@ -12,4 +12,5 @@ void main() {
     // gl_Position = vec4(position, 0.0, 1.0);
     // gl_Position = vec4(inputData.positions[gl_VertexIndex], 0.0, 1.0);
     gl_Position = vertexData.positions[gl_VertexIndex];
-}
+    // gl_Position = vec4(position, 0.0, 1.0);
+}

samples/descriptor_heap/descriptor_heap.c

@@ -0,0 +1,372 @@
+#include <evk/evk.h>
+#include <ev_numeric.h>
+#include <ev_helpers.h>
+#include <ev_log.h>
+
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+evstring PROJECT_NAME = evstr("heap_triangle");
+
+char vertexShaderBytes[] = {
+#embed "shaders/heap_triangle.vert"
+  ,'\0'
+};
+char fragmentShaderBytes[] = {
+#embed "shaders/heap_triangle.frag"
+  ,'\0'
+};
+
+int main(void)
+{
+  u32 width = 1280;
+  u32 height = 800;
+
+  evkInstance instance = evkCreateInstance((evkInstanceCreateInfo){
+    .applicationInfo = EV_DEFAULT(evkApplicationInfo),
+    .layers = svec_init(evstring, {
+      evstr("VK_LAYER_KHRONOS_validation"),
+    }),
+    .extensions = svec_init(evstring, {
+      evstr("VK_KHR_surface"),
+// TODO Get these from GLFW
+#if EV_OS_WINDOWS
+      evstr("VK_KHR_win32_surface"),
+#elif EV_OS_LINUX
+      evstr("VK_KHR_xcb_surface"),
+#endif
+    }),
+  });
+
+  if(instance.vk == EV_INVALID(VkInstance))
+  {
+    ev_log_error("Instance creation failed.");
+    goto InstanceCreationFailed;
+  }
+  ev_log_info("Instance was created successfully.");
+
+  evkDevice device = evkCreateDevice((evkDeviceCreateInfo) {
+      .instance = instance,
+      // TODO Add a fallback physical device option.
+      // .physicalDeviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
+      .physicalDeviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
+      .queueRequirements = svec_init(evkDeviceQueueRequirement, {
+          { VK_QUEUE_GRAPHICS_BIT, 1 },
+          { VK_QUEUE_COMPUTE_BIT , 1 },
+      }),
+      .deviceExtensions = svec_init(evstring, {
+        evstr("VK_KHR_swapchain"),
+        evstr("VK_KHR_dynamic_rendering"),
+        evstr("VK_KHR_depth_stencil_resolve"),
+        evstr("VK_KHR_create_renderpass2"),
+        evstr("VK_KHR_synchronization2"),
+        evstr("VK_KHR_buffer_device_address"),
+        evstr("VK_EXT_descriptor_indexing"),
+        evstr("VK_KHR_maintenance5"),
+        evstr("VK_EXT_descriptor_heap"),
+        evstr(VK_EXT_SHADER_OBJECT_EXTENSION_NAME),
+        evstr(VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME),
+      }),
+  });
+
+  if(device.vk == EV_INVALID(VkDevice))
+  {
+    ev_log_error("Couldn't create a VkDevice");
+    goto DeviceCreationFailed;
+  }
+  ev_log_info("Logical Device created successfully.");
+
+  VkQueue graphicsQueue;
+  vkGetDeviceQueue(device.vk, device.queueFamilies[VK_QUEUE_GRAPHICS_BIT].familyIndex, 0, &graphicsQueue);
+
+  if (!glfwInit())
+  {
+    ev_log_error("GLFW Initialization failed.");
+    goto GLFWInitFailed;
+  }
+
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+  GLFWwindow* window = glfwCreateWindow(width, height, "evk", NULL, NULL);
+  if(!window)
+  {
+    ev_log_error("Window Creation Failed.");
+    goto WindowCreationFailed;
+  }
+
+  VkSurfaceKHR surface;
+  VkResult err = EVK_CHECK(glfwCreateWindowSurface(instance.vk, window, NULL, &surface));
+  if (err)
+  {
+    ev_log_error("Surface creation failed.");
+    goto VKSurfaceCreationFailed;
+  }
+
+  evkGPUAllocator allocator = evkGPUCreateAllocator(device);
+
+  evkSwapChain swapChain = evkCreateSwapChain((evkSwapChainCreateInfo){
+    .device = device,
+    .surface = surface,
+    .width = width,
+    .height = height,
+    .imageCount = 3,
+  });
+
+  evkCommandPool commandPool = evkCreateCommandPool((evkCommandPoolCreateInfo) {
+    .device = device,
+    .queueFlags = VK_QUEUE_GRAPHICS_BIT,
+    .poolFlags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
+  });
+
+  vec(evkCommandBuffer) commandBuffers = evkAllocateCommandBuffers(device, commandPool, vec_len(&swapChain.images), true);
+
+  evkShaderCompiler compiler = evkCreateShaderCompiler();
+
+  evstring vertexShaderText = evstring_new(vertexShaderBytes);
+  evstring fragmentShaderText = evstring_new(fragmentShaderBytes);
+
+  evkShader vertShader = evkInitShaderFromString(device, compiler, evstr("heap_triangle.vert"),vertexShaderText, VK_SHADER_STAGE_VERTEX_BIT);
+  evkShader fragShader = evkInitShaderFromString(device, compiler, evstr("heap_triangle.frag"), fragmentShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
+
+  evstring_free(vertexShaderText);
+  evstring_free(fragmentShaderText);
+
+  evkDestroyShaderCompiler(compiler);
+
+  evkColorAttachment colorAttachment0 = {
+    swapChain.surfaceFormat.format,
+    EV_DEFAULT(VkPipelineColorBlendAttachmentState)
+  };
+
+  // TODO Get this from shader reflection data
+  // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayout(
+  //   &device, svec_init(evkDescriptorBinding, {
+  //     {
+  //       .name = evstr("positions"),
+  //       .binding = 0,
+  //       .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+  //       .descriptorCount = 1,
+  //       .stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS,
+  //     },
+  //   })
+  // );
+  // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayoutFromBindings(&device, vertShader.reflect.bindings);
+
+  // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayoutFromShaders(&device, svec_init(evkShader, {vertShader, fragShader}));
+
+  evkPipelineCreateInfo pipelineCreateInfo = EV_DEFAULT(evkPipelineCreateInfo,
+    dynamicStates = svec_init(VkDynamicState, {
+      VK_DYNAMIC_STATE_VIEWPORT,
+      VK_DYNAMIC_STATE_SCISSOR,
+    }),
+    shaderStages = svec_init(evkShader, {
+      vertShader,
+      fragShader,
+    }),
+    colorAttachments = svec_init(evkColorAttachment, {
+      colorAttachment0,
+    }),
+    viewportCountOverride = 1,
+
+    vertexBufferLayouts = svec_init(evkVertexBufferLayout, {
+      {{ // VB #0
+        { EVK_VERTEX_ATTRIBUTE_POSITION, EVK_FMT_FLOAT32, 2 },
+      }},
+    }),
+
+    // setLayouts = svec_init(evkDescriptorSetLayout, {setLayout_0}),
+  );
+
+  evkBuffer resourceDescriptorHeap = evkCreateBuffer(&device, (evkBufferCreateInfo) {
+    .sizeInBytes = 16 * 4, // bufferDescriptorSize is 16 on my current device
+    .usage = VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    .exclusive = true,
+    .allocationCreateInfo = {
+      .allocationFlags = EVK_GPU_ALLOCATION_CREATE_MAPPED_BIT | EVK_GPU_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
+      .allocator = allocator,
+    }
+  });
+
+
+  evkBuffer uniBuf = evkCreateBuffer(&device, (evkBufferCreateInfo) {
+    .sizeInBytes = 12 * 4,
+    .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    .allocationCreateInfo = {
+      .allocationFlags = EVK_GPU_ALLOCATION_CREATE_MAPPED_BIT | EVK_GPU_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
+      .allocator = allocator,
+    },
+    .exclusive = true,
+  });
+
+  float* uni_arr = (float*)uniBuf.allocData.allocationInfo.vma.pMappedData;
+  uni_arr[0] =  0.0f; uni_arr[1] = -0.5f; uni_arr[2]  = 0.0f; uni_arr[3]  = 1.0f;
+  uni_arr[4] =  0.5f; uni_arr[5] =  0.5f; uni_arr[6]  = 0.0f; uni_arr[7]  = 1.0f;
+  uni_arr[8] = -0.5f; uni_arr[9] =  0.5f; uni_arr[10] = 0.0f; uni_arr[11] = 1.0f;
+
+  // evkSetDescriptor(&set_0, evstr("vertexData"), &uniBuf);
+
+  VkResourceDescriptorInfoEXT resource = {
+    .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+    .type  = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+    .data.pAddressRange = &uniBuf.addressRange
+  };
+
+  VkHostAddressRangeEXT descriptor = {
+    .address = resourceDescriptorHeap.allocData.allocationInfo.vma.pMappedData,
+    .size = 16
+  };
+
+  vkWriteResourceDescriptorsEXT(device.vk, 1, &resource, &descriptor);
+
+  VkViewport viewport = EV_DEFAULT(VkViewport, width=width, height=height);
+  VkRect2D scissor = EV_DEFAULT(VkRect2D,extent.width=width, extent.height=height);
+
+  evkPipeline graphicsPipeline = evkCreatePipeline(device, pipelineCreateInfo);
+
+  u32 imageCount = vec_len(&swapChain.images);
+
+  VkFence drawFence = evkCreateFence(device, false);
+  vec(VkSemaphore) imageAcquiredSemaphores = vec_init(VkSemaphore);
+  vec(VkSemaphore) drawFinishedSemaphores = vec_init(VkSemaphore);
+  for(u32 i = 0; i < imageCount; i++)
+  {
+    imageAcquiredSemaphores[i] = evkCreateSemaphore(device);
+    drawFinishedSemaphores[i] = evkCreateSemaphore(device);
+  }
+  // VkSemaphore imageAcquiredSemaphore = evkCreateSemaphore(device);
+  // VkSemaphore drawFinishedSemaphore = evkCreateSemaphore(device);
+
+  i32 imageIdx = -1;
+  while(!glfwWindowShouldClose(window))
+  {
+    imageIdx = (imageIdx + 1) % imageCount;
+    u32 swapChainImageIdx;
+    EVK_CHECK(vkAcquireNextImageKHR(device.vk, swapChain.vk, UInt64.MAX, imageAcquiredSemaphores[imageIdx], VK_NULL_HANDLE, &swapChainImageIdx));
+
+    evkCommandBuffer cmdbuf = commandBuffers[imageIdx];
+
+    VkRenderingAttachmentInfoKHR colorAttachment = EV_DEFAULT(VkRenderingAttachmentInfoKHR,
+      imageView = swapChain.imageViews[swapChainImageIdx].vk,
+      loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+      storeOp= VK_ATTACHMENT_STORE_OP_STORE,
+    );
+
+    VkRenderingInfo renderingInfo = EV_DEFAULT(VkRenderingInfo,
+      renderArea.extent = ((VkExtent2D){width, height}),
+      pColorAttachments = &colorAttachment,
+      colorAttachmentCount = 1,
+    );
+
+    evkBeginPrimaryCommandBuffer(&cmdbuf);
+    {
+      evkCmdImageBarrier(&cmdbuf, EV_DEFAULT(VkImageMemoryBarrier,
+        image = swapChain.images[swapChainImageIdx].vk,
+        newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
+        subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT
+      ));
+
+      // VkDeviceSize offset = 0;
+      // vkCmdBindVertexBuffers(cmdbuf.vk, 0, 1, &vertBuf.vk, &offset);
+
+      // evkCmdBindDescriptorSets(&cmdbuf, &graphicsPipeline, svec_init(evkDescriptorSet, { set_0 }), svec_init(u32, { 0 }));
+
+      vkCmdSetScissor(cmdbuf.vk, 0, 1, &scissor);
+      vkCmdSetViewport(cmdbuf.vk, 0, 1, &viewport);
+
+      vkCmdBindResourceHeapEXT(cmdbuf.vk, &(VkBindHeapInfoEXT) {
+        .sType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
+        .heapRange = resourceDescriptorHeap.addressRange,
+      });
+
+      vkCmdBeginRenderingKHR(cmdbuf.vk, &renderingInfo);
+
+      evkCmdBindPipeline(&cmdbuf, &graphicsPipeline);
+      vkCmdDraw(cmdbuf.vk, 3, 1, 0, 0);
+
+      vkCmdEndRenderingKHR(cmdbuf.vk);
+
+      evkCmdImageBarrier(&cmdbuf, EV_DEFAULT(VkImageMemoryBarrier,
+        image = swapChain.images[swapChainImageIdx].vk,
+        oldLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
+        newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+        subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT
+      ));
+    }
+    evkEndCommandBuffer(&cmdbuf);
+
+    VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
+
+    VkSubmitInfo submitInfo = {
+      .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+      .pCommandBuffers = &cmdbuf.vk, // TODO This won't work with more than a single cmdbuf
+      .commandBufferCount = 1,
+      .waitSemaphoreCount = 1,
+      .pWaitSemaphores = &imageAcquiredSemaphores[imageIdx],
+      .pWaitDstStageMask = waitStages,
+      .signalSemaphoreCount = 1,
+      .pSignalSemaphores = &drawFinishedSemaphores[swapChainImageIdx],
+    };
+
+    vkQueueSubmit(graphicsQueue, 1, &submitInfo, drawFence);
+    vkWaitForFences(device.vk, 1, &drawFence, VK_TRUE, UInt64.MAX);
+    vkResetFences(device.vk, 1, &drawFence);
+
+    VkPresentInfoKHR presentInfo = {
+      .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+      .waitSemaphoreCount = 1,
+      .pWaitSemaphores = &drawFinishedSemaphores[swapChainImageIdx],
+      .swapchainCount = 1,
+      .pSwapchains = &swapChain.vk,
+      .pImageIndices = &swapChainImageIdx,
+    };
+    vkQueuePresentKHR(graphicsQueue, &presentInfo);
+
+    vkResetCommandBuffer(cmdbuf.vk,VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
+
+    // Main Loop
+    glfwPollEvents();
+  }
+
+  vkQueueWaitIdle(graphicsQueue);
+
+  vkDestroyFence(device.vk, drawFence, NULL);
+  for(u32 i = 0; i < imageCount; i++)
+  {
+    vkDestroySemaphore(device.vk, imageAcquiredSemaphores[i], NULL);
+    vkDestroySemaphore(device.vk, drawFinishedSemaphores[i], NULL);
+  }
+  // vkDestroySemaphore(device.vk, imageAcquiredSemaphore, NULL);
+  // vkDestroySemaphore(device.vk, drawFinishedSemaphore, NULL);
+
+  evkDestroyPipeline(graphicsPipeline);
+
+  // evkDestroyBuffer(vertBuf);
+  evkDestroyBuffer(uniBuf);
+
+  // evkDestroyDescriptorSet(&device, &set_0);
+  // evkDestroyDescriptorSetLayout(&device, &setLayout_0);
+
+  evkDestroyShader(device, vertShader);
+  evkDestroyShader(device, fragShader);
+
+  evkFreeCommandBuffers(device, commandPool, commandBuffers);
+  evkDestroyCommandPool(device, commandPool);
+
+  evkGPUDestroyAllocator(allocator);
+
+  evkDestroySwapChain(device, swapChain);
+
+// SwapchainCreationFailed:
+  vkDestroySurfaceKHR(instance.vk, swapChain.surface, NULL);
+
+VKSurfaceCreationFailed:
+WindowCreationFailed:
+  glfwTerminate();
+
+GLFWInitFailed:
+  evkDestroyDevice(device);
+
+DeviceCreationFailed:
+  evkDestroyInstance(instance);
+InstanceCreationFailed:
+  return 0;
+}

samples/descriptor_heap/meson.build

@@ -0,0 +1,10 @@
+
+executable(
+  'descriptor_heap',
+  'descriptor_heap.c',
+  dependencies: [
+    dependency('evk'),
+    dependency('glfw3'),
+  ],
+  c_args: evk_c_args,
+)

samples/descriptor_heap/shaders/heap_triangle.frag

@@ -0,0 +1,10 @@
+#version 450
+#pragma shader_stage(fragment)
+
+#extension GL_EXT_descriptor_heap: require
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(0.f, 1.f, 0.f, 1.f);
+}

samples/descriptor_heap/shaders/heap_triangle.vert

@@ -0,0 +1,12 @@
+#version 450
+#pragma shader_stage(vertex)
+
+#extension GL_EXT_descriptor_heap: require
+
+layout(descriptor_heap) uniform data {
+  vec4 positions[3];
+} vertexData[];
+
+void main() {
+  gl_Position = vertexData[0].positions[gl_VertexIndex];
+}

samples/mesh_shaders/mesh_shaders.c

@@ -0,0 +1,372 @@
+#include <evk/evk.h>
+#include <ev_numeric.h>
+#include <ev_helpers.h>
+#include <ev_log.h>
+
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+evstring PROJECT_NAME = evstr("mesh_triangle");
+
+char vertexShaderBytes[] = {
+#embed "shaders/mesh_triangle.vert"
+  ,'\0'
+};
+char fragmentShaderBytes[] = {
+#embed "shaders/mesh_triangle.frag"
+  ,'\0'
+};
+
+int main(void)
+{
+  u32 width = 1280;
+  u32 height = 800;
+
+  evkInstance instance = evkCreateInstance((evkInstanceCreateInfo){
+    .applicationInfo = EV_DEFAULT(evkApplicationInfo),
+    .layers = svec_init(evstring, {
+      evstr("VK_LAYER_KHRONOS_validation"),
+    }),
+    .extensions = svec_init(evstring, {
+      evstr("VK_KHR_surface"),
+// TODO Get these from GLFW
+#if EV_OS_WINDOWS
+      evstr("VK_KHR_win32_surface"),
+#elif EV_OS_LINUX
+      evstr("VK_KHR_xcb_surface"),
+#endif
+    }),
+  });
+
+  if(instance.vk == EV_INVALID(VkInstance))
+  {
+    ev_log_error("Instance creation failed.");
+    goto InstanceCreationFailed;
+  }
+  ev_log_info("Instance was created successfully.");
+
+  evkDevice device = evkCreateDevice((evkDeviceCreateInfo) {
+      .instance = instance,
+      // TODO Add a fallback physical device option.
+      // .physicalDeviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
+      .physicalDeviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
+      .queueRequirements = svec_init(evkDeviceQueueRequirement, {
+          { VK_QUEUE_GRAPHICS_BIT, 1 },
+          { VK_QUEUE_COMPUTE_BIT , 1 },
+      }),
+      .deviceExtensions = svec_init(evstring, {
+        evstr("VK_KHR_swapchain"),
+        evstr("VK_KHR_dynamic_rendering"),
+        evstr("VK_KHR_depth_stencil_resolve"),
+        evstr("VK_KHR_create_renderpass2"),
+        evstr("VK_KHR_synchronization2"),
+        evstr("VK_KHR_buffer_device_address"),
+        evstr("VK_EXT_descriptor_indexing"),
+        evstr("VK_KHR_maintenance5"),
+        evstr("VK_EXT_descriptor_heap"),
+        evstr(VK_EXT_SHADER_OBJECT_EXTENSION_NAME),
+        evstr(VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME),
+      }),
+  });
+
+  if(device.vk == EV_INVALID(VkDevice))
+  {
+    ev_log_error("Couldn't create a VkDevice");
+    goto DeviceCreationFailed;
+  }
+  ev_log_info("Logical Device created successfully.");
+
+  VkQueue graphicsQueue;
+  vkGetDeviceQueue(device.vk, device.queueFamilies[VK_QUEUE_GRAPHICS_BIT].familyIndex, 0, &graphicsQueue);
+
+  if (!glfwInit())
+  {
+    ev_log_error("GLFW Initialization failed.");
+    goto GLFWInitFailed;
+  }
+
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+  GLFWwindow* window = glfwCreateWindow(width, height, "evk", NULL, NULL);
+  if(!window)
+  {
+    ev_log_error("Window Creation Failed.");
+    goto WindowCreationFailed;
+  }
+
+  VkSurfaceKHR surface;
+  VkResult err = EVK_CHECK(glfwCreateWindowSurface(instance.vk, window, NULL, &surface));
+  if (err)
+  {
+    ev_log_error("Surface creation failed.");
+    goto VKSurfaceCreationFailed;
+  }
+
+  evkGPUAllocator allocator = evkGPUCreateAllocator(device);
+
+  evkSwapChain swapChain = evkCreateSwapChain((evkSwapChainCreateInfo){
+    .device = device,
+    .surface = surface,
+    .width = width,
+    .height = height,
+    .imageCount = 3,
+  });
+
+  evkCommandPool commandPool = evkCreateCommandPool((evkCommandPoolCreateInfo) {
+    .device = device,
+    .queueFlags = VK_QUEUE_GRAPHICS_BIT,
+    .poolFlags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
+  });
+
+  vec(evkCommandBuffer) commandBuffers = evkAllocateCommandBuffers(device, commandPool, vec_len(&swapChain.images), true);
+
+  evkShaderCompiler compiler = evkCreateShaderCompiler();
+
+  evstring vertexShaderText = evstring_new(vertexShaderBytes);
+  evstring fragmentShaderText = evstring_new(fragmentShaderBytes);
+
+  evkShader vertShader = evkInitShaderFromString(device, compiler, evstr("mesh_triangle.vert"),vertexShaderText, VK_SHADER_STAGE_VERTEX_BIT);
+  evkShader fragShader = evkInitShaderFromString(device, compiler, evstr("mesh_triangle.frag"), fragmentShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
+
+  evstring_free(vertexShaderText);
+  evstring_free(fragmentShaderText);
+
+  evkDestroyShaderCompiler(compiler);
+
+  evkColorAttachment colorAttachment0 = {
+    swapChain.surfaceFormat.format,
+    EV_DEFAULT(VkPipelineColorBlendAttachmentState)
+  };
+
+  // TODO Get this from shader reflection data
+  // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayout(
+  //   &device, svec_init(evkDescriptorBinding, {
+  //     {
+  //       .name = evstr("positions"),
+  //       .binding = 0,
+  //       .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+  //       .descriptorCount = 1,
+  //       .stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS,
+  //     },
+  //   })
+  // );
+  // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayoutFromBindings(&device, vertShader.reflect.bindings);
+
+  // evkDescriptorSetLayout setLayout_0 = evkCreateDescriptorSetLayoutFromShaders(&device, svec_init(evkShader, {vertShader, fragShader}));
+
+  evkPipelineCreateInfo pipelineCreateInfo = EV_DEFAULT(evkPipelineCreateInfo,
+    dynamicStates = svec_init(VkDynamicState, {
+      VK_DYNAMIC_STATE_VIEWPORT,
+      VK_DYNAMIC_STATE_SCISSOR,
+    }),
+    shaderStages = svec_init(evkShader, {
+      vertShader,
+      fragShader,
+    }),
+    colorAttachments = svec_init(evkColorAttachment, {
+      colorAttachment0,
+    }),
+    viewportCountOverride = 1,
+
+    vertexBufferLayouts = svec_init(evkVertexBufferLayout, {
+      {{ // VB #0
+        { EVK_VERTEX_ATTRIBUTE_POSITION, EVK_FMT_FLOAT32, 2 },
+      }},
+    }),
+
+    // setLayouts = svec_init(evkDescriptorSetLayout, {setLayout_0}),
+  );
+
+  evkBuffer resourceDescriptorHeap = evkCreateBuffer(&device, (evkBufferCreateInfo) {
+    .sizeInBytes = 16 * 4, // bufferDescriptorSize is 16 on my current device
+    .usage = VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    .exclusive = true,
+    .allocationCreateInfo = {
+      .allocationFlags = EVK_GPU_ALLOCATION_CREATE_MAPPED_BIT | EVK_GPU_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
+      .allocator = allocator,
+    }
+  });
+
+
+  evkBuffer uniBuf = evkCreateBuffer(&device, (evkBufferCreateInfo) {
+    .sizeInBytes = 12 * 4,
+    .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    .allocationCreateInfo = {
+      .allocationFlags = EVK_GPU_ALLOCATION_CREATE_MAPPED_BIT | EVK_GPU_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
+      .allocator = allocator,
+    },
+    .exclusive = true,
+  });
+
+  float* uni_arr = (float*)uniBuf.allocData.allocationInfo.vma.pMappedData;
+  uni_arr[0] =  0.0f; uni_arr[1] = -0.5f; uni_arr[2]  = 0.0f; uni_arr[3]  = 1.0f;
+  uni_arr[4] =  0.5f; uni_arr[5] =  0.5f; uni_arr[6]  = 0.0f; uni_arr[7]  = 1.0f;
+  uni_arr[8] = -0.5f; uni_arr[9] =  0.5f; uni_arr[10] = 0.0f; uni_arr[11] = 1.0f;
+
+  // evkSetDescriptor(&set_0, evstr("vertexData"), &uniBuf);
+
+  VkResourceDescriptorInfoEXT resource = {
+    .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+    .type  = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+    .data.pAddressRange = &uniBuf.addressRange
+  };
+
+  VkHostAddressRangeEXT descriptor = {
+    .address = resourceDescriptorHeap.allocData.allocationInfo.vma.pMappedData,
+    .size = 16
+  };
+
+  vkWriteResourceDescriptorsEXT(device.vk, 1, &resource, &descriptor);
+
+  VkViewport viewport = EV_DEFAULT(VkViewport, width=width, height=height);
+  VkRect2D scissor = EV_DEFAULT(VkRect2D,extent.width=width, extent.height=height);
+
+  evkPipeline graphicsPipeline = evkCreatePipeline(device, pipelineCreateInfo);
+
+  u32 imageCount = vec_len(&swapChain.images);
+
+  VkFence drawFence = evkCreateFence(device, false);
+  vec(VkSemaphore) imageAcquiredSemaphores = vec_init(VkSemaphore);
+  vec(VkSemaphore) drawFinishedSemaphores = vec_init(VkSemaphore);
+  for(u32 i = 0; i < imageCount; i++)
+  {
+    imageAcquiredSemaphores[i] = evkCreateSemaphore(device);
+    drawFinishedSemaphores[i] = evkCreateSemaphore(device);
+  }
+  // VkSemaphore imageAcquiredSemaphore = evkCreateSemaphore(device);
+  // VkSemaphore drawFinishedSemaphore = evkCreateSemaphore(device);
+
+  i32 imageIdx = -1;
+  while(!glfwWindowShouldClose(window))
+  {
+    imageIdx = (imageIdx + 1) % imageCount;
+    u32 swapChainImageIdx;
+    EVK_CHECK(vkAcquireNextImageKHR(device.vk, swapChain.vk, UInt64.MAX, imageAcquiredSemaphores[imageIdx], VK_NULL_HANDLE, &swapChainImageIdx));
+
+    evkCommandBuffer cmdbuf = commandBuffers[imageIdx];
+
+    VkRenderingAttachmentInfoKHR colorAttachment = EV_DEFAULT(VkRenderingAttachmentInfoKHR,
+      imageView = swapChain.imageViews[swapChainImageIdx].vk,
+      loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+      storeOp= VK_ATTACHMENT_STORE_OP_STORE,
+    );
+
+    VkRenderingInfo renderingInfo = EV_DEFAULT(VkRenderingInfo,
+      renderArea.extent = ((VkExtent2D){width, height}),
+      pColorAttachments = &colorAttachment,
+      colorAttachmentCount = 1,
+    );
+
+    evkBeginPrimaryCommandBuffer(&cmdbuf);
+    {
+      evkCmdImageBarrier(&cmdbuf, EV_DEFAULT(VkImageMemoryBarrier,
+        image = swapChain.images[swapChainImageIdx].vk,
+        newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
+        subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT
+      ));
+
+      // VkDeviceSize offset = 0;
+      // vkCmdBindVertexBuffers(cmdbuf.vk, 0, 1, &vertBuf.vk, &offset);
+
+      // evkCmdBindDescriptorSets(&cmdbuf, &graphicsPipeline, svec_init(evkDescriptorSet, { set_0 }), svec_init(u32, { 0 }));
+
+      vkCmdSetScissor(cmdbuf.vk, 0, 1, &scissor);
+      vkCmdSetViewport(cmdbuf.vk, 0, 1, &viewport);
+
+      vkCmdBindResourceHeapEXT(cmdbuf.vk, &(VkBindHeapInfoEXT) {
+        .sType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
+        .heapRange = resourceDescriptorHeap.addressRange,
+      });
+
+      vkCmdBeginRenderingKHR(cmdbuf.vk, &renderingInfo);
+
+      evkCmdBindPipeline(&cmdbuf, &graphicsPipeline);
+      vkCmdDraw(cmdbuf.vk, 3, 1, 0, 0);
+
+      vkCmdEndRenderingKHR(cmdbuf.vk);
+
+      evkCmdImageBarrier(&cmdbuf, EV_DEFAULT(VkImageMemoryBarrier,
+        image = swapChain.images[swapChainImageIdx].vk,
+        oldLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
+        newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+        subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT
+      ));
+    }
+    evkEndCommandBuffer(&cmdbuf);
+
+    VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
+
+    VkSubmitInfo submitInfo = {
+      .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+      .pCommandBuffers = &cmdbuf.vk, // TODO This won't work with more than a single cmdbuf
+      .commandBufferCount = 1,
+      .waitSemaphoreCount = 1,
+      .pWaitSemaphores = &imageAcquiredSemaphores[imageIdx],
+      .pWaitDstStageMask = waitStages,
+      .signalSemaphoreCount = 1,
+      .pSignalSemaphores = &drawFinishedSemaphores[swapChainImageIdx],
+    };
+
+    vkQueueSubmit(graphicsQueue, 1, &submitInfo, drawFence);
+    vkWaitForFences(device.vk, 1, &drawFence, VK_TRUE, UInt64.MAX);
+    vkResetFences(device.vk, 1, &drawFence);
+
+    VkPresentInfoKHR presentInfo = {
+      .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+      .waitSemaphoreCount = 1,
+      .pWaitSemaphores = &drawFinishedSemaphores[swapChainImageIdx],
+      .swapchainCount = 1,
+      .pSwapchains = &swapChain.vk,
+      .pImageIndices = &swapChainImageIdx,
+    };
+    vkQueuePresentKHR(graphicsQueue, &presentInfo);
+
+    vkResetCommandBuffer(cmdbuf.vk,VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
+
+    // Main Loop
+    glfwPollEvents();
+  }
+
+  vkQueueWaitIdle(graphicsQueue);
+
+  vkDestroyFence(device.vk, drawFence, NULL);
+  for(u32 i = 0; i < imageCount; i++)
+  {
+    vkDestroySemaphore(device.vk, imageAcquiredSemaphores[i], NULL);
+    vkDestroySemaphore(device.vk, drawFinishedSemaphores[i], NULL);
+  }
+  // vkDestroySemaphore(device.vk, imageAcquiredSemaphore, NULL);
+  // vkDestroySemaphore(device.vk, drawFinishedSemaphore, NULL);
+
+  evkDestroyPipeline(graphicsPipeline);
+
+  // evkDestroyBuffer(vertBuf);
+  evkDestroyBuffer(uniBuf);
+
+  // evkDestroyDescriptorSet(&device, &set_0);
+  // evkDestroyDescriptorSetLayout(&device, &setLayout_0);
+
+  evkDestroyShader(device, vertShader);
+  evkDestroyShader(device, fragShader);
+
+  evkFreeCommandBuffers(device, commandPool, commandBuffers);
+  evkDestroyCommandPool(device, commandPool);
+
+  evkGPUDestroyAllocator(allocator);
+
+  evkDestroySwapChain(device, swapChain);
+
+// SwapchainCreationFailed:
+  vkDestroySurfaceKHR(instance.vk, swapChain.surface, NULL);
+
+VKSurfaceCreationFailed:
+WindowCreationFailed:
+  glfwTerminate();
+
+GLFWInitFailed:
+  evkDestroyDevice(device);
+
+DeviceCreationFailed:
+  evkDestroyInstance(instance);
+InstanceCreationFailed:
+  return 0;
+}

samples/mesh_shaders/meson.build

@@ -0,0 +1,10 @@
+
+executable(
+  'mesh_shaders',
+  'mesh_shaders.c',
+  dependencies: [
+    dependency('evk'),
+    dependency('glfw3'),
+  ],
+  c_args: evk_c_args,
+)

samples/mesh_shaders/shaders/mesh_triangle.frag

@@ -0,0 +1,10 @@
+#version 450
+#pragma shader_stage(fragment)
+
+#extension GL_EXT_descriptor_heap: require
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(0.f, 1.f, 0.f, 1.f);
+}

samples/mesh_shaders/shaders/mesh_triangle.vert

@@ -0,0 +1,12 @@
+#version 450
+#pragma shader_stage(vertex)
+
+#extension GL_EXT_descriptor_heap: require
+
+layout(descriptor_heap) uniform data {
+  vec4 positions[3];
+} vertexData[];
+
+void main() {
+  gl_Position = vertexData[0].positions[gl_VertexIndex];
+}

samples/meson.build

@@ -1 +1,3 @@
-subdir('basic_triangle')
+# subdir('basic_triangle')
+# subdir('descriptor_heap')
+subdir('mesh_shaders')

subprojects/packagefiles/shaderc/fixes.diff

@@ -14,14 +14,4 @@ index d44f62a..16bad95 100644
 +    endif()
      add_subdirectory(${SHADERC_GLSLANG_DIR} glslang)
    endif()
-   if (NOT TARGET glslang)
+   if (NOT TARGET glslang)
-diff --git a/utils/git-sync-deps b/utils/git-sync-deps
-index eecfbe9..73df6e5 100755
---- a/utils/git-sync-deps
-+++ b/utils/git-sync-deps
-@@ -279,4 +279,4 @@ def main(argv):
- 
- 
- if __name__ == '__main__':
--  exit(main(sys.argv[1:]))
-+  sys.exit(main(sys.argv[1:]))

subprojects/packagefiles/shaderc/meson.build

@@ -2,6 +2,7 @@ project('libshaderc', 'cpp')
 
 python = find_program('python3')
 run_command(python, './utils/git-sync-deps', check: true)
+run_command(python, './utils/update_build_version.py', check: true)
 
 cmake  = import('cmake')
 opts = cmake.subproject_options()
@@ -24,4 +25,4 @@ shaderc_dep = declare_dependency(dependencies: [
     shaderc_proj.dependency('GenericCodeGen'),
     shaderc_proj.dependency('MachineIndependent'),
 ])
-meson.override_dependency('shaderc', shaderc_dep)
+meson.override_dependency('shaderc', shaderc_dep)

subprojects/shaderc.wrap

@@ -2,11 +2,11 @@
 directory = shaderc
 
 url = https://github.com/google/shaderc
-revision = v2024.4
+revision = v2026.2
 depth=1
 patch_directory = shaderc
 
 diff_files = shaderc/fixes.diff
 
 [provide]
-dependency_names = shaderc
+dependency_names = shaderc