Can now configure Vulkan with JSON. ENJOY!

json_mods.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include <nlohmann/json.hpp>
+#include <nlohmann/json_fwd.hpp>
+#include <optional>
+
+#define ENROLL_COMPONENT(COMPONENT, ...)                         \
+    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(COMPONENT, __VA_ARGS__);  \
+    template <> struct NameOf<COMPONENT> {                       \
+      static constexpr const char *name = #COMPONENT;            \
+    };
+
+// partial specialization (full specialization works too)
+namespace nlohmann {
+  template <typename T>
+    struct adl_serializer<std::optional<T>> {
+      static void to_json(json& j, const std::optional<T>& opt) {
+        if (opt == std::nullopt) {
+          j = nullptr;
+        } else {
+          j = *opt; // this will call adl_serializer<T>::to_json which will
+          // find the free function to_json in T's namespace!
+        }
+      }
+
+      static void from_json(const json& j, std::optional<T>& opt) {
+        if (j.is_null() || j == false) {
+          opt = std::nullopt;
+        } else {
+          opt = std::make_optional<T>(j.template get<T>());
+          // same as above, but with adl_serializer<T>::from_json
+        }
+      }
+    };
+}

meson.build

@@ -104,6 +104,7 @@ else
   })
 endif
 
+json = subproject('nlohmann_json').get_variable('nlohmann_json_dep')
 vkbootstrap_proj = cmake.subproject('vk-bootstrap', options: vk_opts)
 vkbootstrap = vkbootstrap_proj.get_variable('vk_bootstrap_dep')
 
@@ -113,6 +114,7 @@ dependencies += [
   glm,
   imgui,
   sdl2,
+  json,
 ]
 
 sources = [

trash_test.hpp

@@ -0,0 +1,8 @@
+#include "vk_types.h"
+#include "json_mods.hpp"
+
+template <typename T> struct NameOf;
+
+ENROLL_COMPONENT(VkSemaphoreCreateInfo, sType);
+ENROLL_COMPONENT(VkFenceCreateInfo, sType);
+ENROLL_COMPONENT(VkImageViewCreateInfo, sType, viewType, subresourceRange.baseMipLevel, subresourceRange.levelCount, subresourceRange.baseArrayLayer, subresourceRange.layerCount);

vk_engine.cpp

@@ -19,7 +19,7 @@
 #define VMA_IMPLEMENTATION
 #include "vk_mem_alloc.h"
 
-constexpr bool bUseValidationLayers = true;
+constexpr bool bUseValidationLayers = false;
 
 VulkanEngine* loadedEngine = nullptr;
 

vk_initializers.cpp

@@ -1,76 +1,126 @@
 #include <vk_initializers.h>
+#include <vulkan/vk_enum_string_helper.h>
+#include "trash_test.hpp"
+
+nlohmann::json DATA = nlohmann::json::parse(R"(
+  {
+  "VkSemaphoreCreateInfo": {
+    "draw": {
+        "sType": 9
+      }
+    },
+  "VkFenceCreateInfo": {
+    "draw": {
+        "sType": 8
+      }
+    },
+  "VkImageViewCreateInfo": {
+    "draw": {
+        "sType": 15,
+        "viewType": 1,
+        "subresourceRange.baseMipLevel": 0,
+        "subresourceRange.levelCount": 1,
+        "subresourceRange.baseArrayLayer": 0,
+        "subresourceRange.layerCount": 1
+      }
+    }
+  }
+)");
+
+template<typename COMPONENT> COMPONENT load(nlohmann::json &data, const std::string& profile) {
+  COMPONENT result{};
+  auto& type_stuff = data[NameOf<COMPONENT>::name];
+  auto& profile_data = type_stuff[profile];
+  nlohmann::from_json(profile_data, result);
+  return result;
+}
 
-// #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-//
-#define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS 1
-#define VULKAN_HPP_NO_CONSTRUCTORS 1
-#include <vulkan/vulkan.hpp>
 
 VkCommandPoolCreateInfo vkinit::command_pool_create_info(uint32_t queueFamilyIndex,
     VkCommandPoolCreateFlags flags /*= 0*/)
 {
-  return vk::CommandPoolCreateInfo{
-    .flags=vk::CommandPoolCreateFlags(flags),
-    .queueFamilyIndex=queueFamilyIndex
-  };
+    VkCommandPoolCreateInfo info = {};
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    info.pNext = nullptr;
+    info.queueFamilyIndex = queueFamilyIndex;
+    info.flags = flags;
+    return info;
 }
 
 
 VkCommandBufferAllocateInfo vkinit::command_buffer_allocate_info(
     VkCommandPool pool, uint32_t count /*= 1*/)
 {
-  return vk::CommandBufferAllocateInfo{
-    .commandPool=pool,
-    .level=vk::CommandBufferLevel::ePrimary,
-    .commandBufferCount=count
-  };
+    VkCommandBufferAllocateInfo info = {};
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    info.pNext = nullptr;
+
+    info.commandPool = pool;
+    info.commandBufferCount = count;
+    info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    return info;
 }
 
 VkFenceCreateInfo vkinit::fence_create_info(VkFenceCreateFlags flags /*=0*/)
 {
-  return vk::FenceCreateInfo{
-    .flags=vk::FenceCreateFlags(flags)
-  };
+  auto info = load<VkFenceCreateInfo>(DATA, "draw");
+  info.flags = flags;
+  return info;
 }
 
 VkSemaphoreCreateInfo vkinit::semaphore_create_info(VkSemaphoreCreateFlags flags/*=0*/)
 {
-  return vk::SemaphoreCreateInfo{
-    .flags=vk::SemaphoreCreateFlags(flags)
-  };
+  auto info = load<VkSemaphoreCreateInfo>(DATA, "draw");
+  info.flags = flags;
+
+  return info;
 }
 
 VkCommandBufferBeginInfo vkinit::command_buffer_begin_info(VkCommandBufferUsageFlags flags /*= 0*/)
 {
-    return vk::CommandBufferBeginInfo{
-      .flags=vk::CommandBufferUsageFlags(flags)
-    };
+    VkCommandBufferBeginInfo info = {};
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    info.pNext = nullptr;
+
+    info.pInheritanceInfo = nullptr;
+    info.flags = flags;
+    return info;
 }
 
 VkImageSubresourceRange vkinit::image_subresource_range(VkImageAspectFlags aspectMask)
 {
-    return vk::ImageSubresourceRange{
-      vk::ImageAspectFlags(aspectMask),
-        0, VK_REMAINING_MIP_LEVELS, 0, VK_REMAINING_ARRAY_LAYERS
-    };
+    VkImageSubresourceRange subImage {};
+    subImage.aspectMask = aspectMask;
+    subImage.baseMipLevel = 0;
+    subImage.levelCount = VK_REMAINING_MIP_LEVELS;
+    subImage.baseArrayLayer = 0;
+    subImage.layerCount = VK_REMAINING_ARRAY_LAYERS;
+
+    return subImage;
 }
 
 VkSemaphoreSubmitInfo vkinit::semaphore_submit_info(VkPipelineStageFlags2 stageMask, VkSemaphore semaphore)
 {
-	return vk::SemaphoreSubmitInfo{
-      .semaphore=vk::Semaphore{semaphore},
-      .value=1,
-      .stageMask=vk::PipelineStageFlags2{stageMask},
-      .deviceIndex=0,
-    };
+	VkSemaphoreSubmitInfo submitInfo{};
+	submitInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
+	submitInfo.pNext = nullptr;
+	submitInfo.semaphore = semaphore;
+	submitInfo.stageMask = stageMask;
+	submitInfo.deviceIndex = 0;
+	submitInfo.value = 1;
+
+	return submitInfo;
 }
 
 VkCommandBufferSubmitInfo vkinit::command_buffer_submit_info(VkCommandBuffer cmd)
 {
-	return vk::CommandBufferSubmitInfo{
-        .commandBuffer=cmd, // commandBuffer
-        .deviceMask=0, // deviceMask
-    };
+	VkCommandBufferSubmitInfo info{};
+	info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
+	info.pNext = nullptr;
+	info.commandBuffer = cmd;
+	info.deviceMask = 0;
+
+	return info;
 }
 
 VkSubmitInfo2 vkinit::submit_info(VkCommandBufferSubmitInfo* cmd, VkSemaphoreSubmitInfo* signalSemaphoreInfo,
@@ -94,56 +144,51 @@ VkSubmitInfo2 vkinit::submit_info(VkCommandBufferSubmitInfo* cmd, VkSemaphoreSub
 
 VkImageCreateInfo vkinit::image_create_info(VkFormat format, VkImageUsageFlags usageFlags, VkExtent3D extent)
 {
-  return vk::ImageCreateInfo{
-    .flags=vk::ImageCreateFlags(0),
-    .imageType=vk::ImageType::e2D,
-    .format=vk::Format{format},
-    .extent=vk::Extent3D{extent.width, extent.height, extent.depth},
-    .mipLevels=1,
-    .arrayLayers=1,
-    .samples=vk::SampleCountFlagBits::e1,
-    .tiling=vk::ImageTiling::eOptimal,
-    .usage=vk::ImageUsageFlags{usageFlags},
-  };
+  VkImageCreateInfo info{};
+  info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+  info.pNext = nullptr;
+
+  info.imageType = VK_IMAGE_TYPE_2D;
+
+  info.format = format;
+  info.extent = extent;
+
+  info.mipLevels = 1;
+  info.arrayLayers = 1;
+
+  info.samples = VK_SAMPLE_COUNT_1_BIT;
+
+  info.tiling = VK_IMAGE_TILING_OPTIMAL;
+  info.usage = usageFlags;
+
+  return info;
 }
 
 VkImageViewCreateInfo vkinit::imageview_create_info(VkFormat format, VkImage image, VkImageAspectFlags aspectFlags)
 {
-  return vk::ImageViewCreateInfo{
-    .image=image,
-    .viewType=vk::ImageViewType::e2D,
-    .format=vk::Format{format},
-    .subresourceRange{
-      .aspectMask=vk::ImageAspectFlags{aspectFlags},
-      .baseMipLevel=0,
-      .levelCount=1,
-      .baseArrayLayer=0,
-      .layerCount=1,
-    }
-  };
+  auto info = load<VkImageViewCreateInfo>(DATA, "draw");
+
+  info.image = image;
+  info.format = format;
+  info.subresourceRange.aspectMask = aspectFlags;
+
+  return info;
 }
 
 VkRenderingAttachmentInfo vkinit::attachment_info(
     VkImageView view, VkClearValue* clear ,VkImageLayout layout /*= VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL*/)
 {
-    vk::RenderingAttachmentInfo colorAttachment{
-        .imageView=view,
-        .imageLayout=vk::ImageLayout(layout),
-        .loadOp=vk::AttachmentLoadOp(clear ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD),
-        .storeOp=vk::AttachmentStoreOp(VK_ATTACHMENT_STORE_OP_STORE),
-    };
+    VkRenderingAttachmentInfo colorAttachment {};
+    colorAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+    colorAttachment.pNext = nullptr;
+
+    colorAttachment.imageView = view;
+    colorAttachment.imageLayout = layout;
+    colorAttachment.loadOp = clear ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
+    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
 
     if (clear) {
-      vk::ArrayWrapper1D<float, 4> thefuckingcolor{{
-        clear->color.float32[0],
-        clear->color.float32[1],
-        clear->color.float32[2],
-        clear->color.float32[3],
-      }};
-
-      colorAttachment.clearValue = vk::ClearValue{
-        .color = thefuckingcolor
-      };
+        colorAttachment.clearValue = *clear;
     }
 
     return colorAttachment;

wraps/nlohmann_json.wrap

@@ -0,0 +1,11 @@
+[wrap-file]
+directory = nlohmann_json-3.11.3
+lead_directory_missing = true
+source_url = https://github.com/nlohmann/json/releases/download/v3.11.3/include.zip
+source_filename = nlohmann_json-3.11.3.zip
+source_hash = a22461d13119ac5c78f205d3df1db13403e58ce1bb1794edc9313677313f4a9d
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/nlohmann_json_3.11.3-1/nlohmann_json-3.11.3.zip
+wrapdb_version = 3.11.3-1
+
+[provide]
+nlohmann_json = nlohmann_json_dep