vulkan version args works! nice

02-vulkan/08-vk-framebuffer-cmd-2/CMakeLists.txt

@@ -21,6 +21,8 @@ om_clang_tidy_enable()
 add_executable(
     08-vk-framebuffer-cmd-2
     main.cxx
+    parser_args_vulkan.cxx
+    parser_args_vulkan.hxx
     platform_sdl3.cxx
     platform_sdl3.hxx
     render.cxx

02-vulkan/08-vk-framebuffer-cmd-2/main.cxx

@@ -10,6 +10,7 @@
 #include <SDL3/SDL_hints.h>
 #include <SDL3/SDL_vulkan.h>
 
+#include "parser_args_vulkan.hxx"
 #include "platform_sdl3.hxx"
 
 int main(int argc, char** argv)
@@ -21,9 +22,18 @@ int main(int argc, char** argv)
 
     cerr.exceptions(ios_base::failbit | ios_base::badbit);
 
-    bool verbose               = argc > 1 && argv[1] == "-v"sv;
-    bool vk_validation_layer   = verbose;
-    bool vk_debug_callback_ext = true;
+    om::tools::parser_args_vulkan args_parser(argc, argv);
+
+    if (!args_parser.help.empty())
+    {
+
+        cout << "usage: " << args_parser.help << '\n';
+        return EXIT_SUCCESS;
+    }
+
+    bool verbose               = args_parser.verbose;
+    bool vk_validation_layer   = args_parser.validation_layer;
+    bool vk_debug_callback_ext = args_parser.debug_callback;
 
     struct null_buffer final : std::streambuf
     {
@@ -88,11 +98,14 @@ int main(int argc, char** argv)
     {
         using namespace om::vulkan;
         platform_sdl3 platform(window.get(), log);
-        render::hints hints{ .verbose                  = verbose,
-                             .enable_validation_layers = vk_validation_layer,
-                             .enable_debug_callback_ext =
-                                 vk_debug_callback_ext };
-        render        render(platform, hints);
+        render::hints hints{
+            .vulkan_version = { .major = args_parser.vulkan_version_major,
+                                .minor = args_parser.vulkan_version_minor },
+            .verbose        = verbose,
+            .enable_validation_layers  = vk_validation_layer,
+            .enable_debug_callback_ext = vk_debug_callback_ext
+        };
+        render render(platform, hints);
 
         bool running = true;
         while (running)

02-vulkan/08-vk-framebuffer-cmd-2/parser_args_vulkan.cxx

@@ -0,0 +1,51 @@
+#include "parser_args_vulkan.hxx"
+
+#include <boost/program_options.hpp>
+
+namespace om::tools
+{
+parser_args_vulkan::parser_args_vulkan(int argc, char** argv)
+{
+    using namespace boost::program_options;
+    std::string         vulkan_version;
+    options_description options("options");
+    options.add_options()("help,h", "print this help");
+    options.add_options()("verbose,v", "enable verbose mode");
+    options.add_options()(
+        "vk_ver",
+        value<std::string>(&vulkan_version)->default_value("1.0"),
+        "desired vulkan version in format 1.0 or 1.1 or 1.2 or 1.3 or 1.4");
+    options.add_options()("vk_validation_layer,l",
+                          "enable VK_LAYER_KHRONOS_validation");
+    options.add_options()("vk_debug_callback,d", "enable VK_EXT_debug_utils");
+
+    variables_map vm;
+    store(parse_command_line(argc, argv, options), vm);
+    notify(vm);
+
+    if (vm.count("help"))
+    {
+        std::stringstream ss;
+        ss << options;
+        help = ss.str();
+        return;
+    }
+
+    verbose          = vm.count("verbose");
+    validation_layer = vm.count("vk_validation_layer");
+    debug_callback   = vm.count("vk_debug_callback");
+
+    // expected format is "1.0" or "1.1" or "1.2" or "1.3" or "1.4"
+    auto index_of_point = vulkan_version.find('.');
+    if (index_of_point == std::string::npos)
+    {
+        std::stringstream ss;
+        ss << options;
+        help = ss.str();
+        return;
+    }
+
+    vulkan_version_major = std::stoi(vulkan_version.substr(0, index_of_point));
+    vulkan_version_minor = std::stoi(vulkan_version.substr(index_of_point + 1));
+}
+} // namespace om::tools

02-vulkan/08-vk-framebuffer-cmd-2/parser_args_vulkan.hxx

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace om::tools
+{
+struct parser_args_vulkan
+{
+    parser_args_vulkan(int argc, char** argv);
+
+    std::string   help;
+    std::uint32_t vulkan_version_major;
+    std::uint32_t vulkan_version_minor;
+    bool          verbose;
+    bool          validation_layer;
+    bool          debug_callback;
+};
+} // namespace om::tools

02-vulkan/08-vk-framebuffer-cmd-2/render.cxx

@@ -292,8 +292,8 @@ void render::create_instance(bool enable_validation_layers,
                              bool enable_debug_callback_ext)
 {
     vk::ApplicationInfo application_info;
-    application_info.apiVersion =
-        VK_API_VERSION_1_3; // without this validation of SPIR-V failed
+    application_info.apiVersion = VK_MAKE_API_VERSION(
+        0, hints_.vulkan_version.major, hints_.vulkan_version.minor, 0);
     vk::InstanceCreateInfo instance_create_info;
     instance_create_info.pApplicationInfo = &application_info;
 

02-vulkan/08-vk-framebuffer-cmd-2/render.hxx

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <iosfwd>
 #include <limits>
 #include <memory> // std::unique_ptr
@@ -80,10 +81,14 @@ class render
 public:
     struct hints
     {
-        std::string vulkan_version;
-        bool        verbose;
-        bool        enable_validation_layers;
-        bool        enable_debug_callback_ext;
+        struct
+        {
+            std::uint32_t major = 1;
+            std::uint32_t minor = 0;
+        } vulkan_version;
+        bool verbose                   = false;
+        bool enable_validation_layers  = false;
+        bool enable_debug_callback_ext = false;
     };
 
     explicit render(platform_interface& platform, hints hints);