vkconfig: Add Vulkan SDK release detection

vkconfig_core/configurator.cpp

@@ -824,8 +824,12 @@ bool Configurator::Load() {
             const QJsonObject& json_object = json_interface_object.value(GetToken(TAB_PREFERENCES)).toObject();
 
             this->use_layer_dev_mode = json_object.value("use_layer_dev_mode").toBool();
+            this->latest_sdk_version = Version(json_object.value("latest_sdk_version").toString().toStdString().c_str());
             this->use_system_tray = json_object.value("use_system_tray").toBool();
             ::SetHomePath(json_object.value("VK_HOME").toString().toStdString());
+            if (json_object.value("VK_DOWNLOAD") != QJsonValue::Undefined) {
+                ::SetDownloadPath(json_object.value("VK_DOWNLOAD").toString().toStdString());
+            }
         }
 
         this->executables.Load(json_root_object);
@@ -873,7 +877,9 @@ bool Configurator::Save() const {
         QJsonObject json_object;
         json_object.insert("use_system_tray", this->use_system_tray);
         json_object.insert("use_layer_dev_mode", this->use_layer_dev_mode);
+        json_object.insert("latest_sdk_version", this->latest_sdk_version.str().c_str());
         json_object.insert("VK_HOME", ::Path(Path::HOME).RelativePath().c_str());
+        json_object.insert("VK_DOWNLOAD", ::Path(Path::DOWNLOAD).RelativePath().c_str());
         json_interface_object.insert(GetToken(TAB_PREFERENCES), json_object);
     }
 

vkconfig_core/configurator.h

@@ -136,6 +136,8 @@ class Configurator {
     TabType active_tab = TAB_CONFIGURATIONS;
     bool advanced = true;
     Path last_path_status = Path(Path::HOME).RelativePath() + "/vkconfig.txt";
+    Version latest_sdk_version = Version::VKHEADER;
+    Version online_sdk_version = Version::NONE;
 
    private:
     int hide_message_boxes_flags = 0;

vkconfig_core/path.cpp

@@ -38,9 +38,10 @@ struct BuiltinDesc {
     const Path::Builtin path;
 };
 
-static const BuiltinDesc VARIABLES[] = {
-    {"${VK_HOME}", Path::HOME},   {"${VK_APPDATA}", Path::APPDATA},       {"${VULKAN_BIN}", Path::BIN},
-    {"${VULKAN_SDK}", Path::SDK}, {"${VULKAN_PROFILES}", Path::PROFILES}, {"${VULKAN_CONTENT}", Path::CONTENT}};
+static const BuiltinDesc VARIABLES[] = {{"${VK_HOME}", Path::HOME},          {"${VK_DOWNLOAD}", Path::DOWNLOAD},
+                                        {"${VK_APPDATA}", Path::APPDATA},    {"${VULKAN_BIN}", Path::BIN},
+                                        {"${VULKAN_SDK}", Path::SDK},        {"${VULKAN_PROFILES}", Path::PROFILES},
+                                        {"${VULKAN_CONTENT}", Path::CONTENT}};
 
 static std::string ConvertSeparators(const std::string& path, const char* native_separator, const char* alien_separator) {
     const std::size_t native_separator_size = std::strlen(native_separator);
@@ -74,13 +75,13 @@ static std::string ConvertSeparators(const std::string& path, const char* native
     return current_path;
 }
 
-static const char* GetNativeSeparator() {
+const char* Path::Separator() {
     static const char* native_separator = VKC_ENV == VKC_ENV_WIN32 ? "\\" : "/";
     return native_separator;
 }
 
 static std::string ConvertNativeSeparators(const std::string& path) {
-    const char* native_separator = GetNativeSeparator();
+    const char* native_separator = Path::Separator();
     const char* alien_separator = VKC_ENV != VKC_ENV_WIN32 ? "\\" : "/";
 
     return ConvertSeparators(path, native_separator, alien_separator);
@@ -247,6 +248,20 @@ static const std::string GetHomeDir() {
     return absolute_path;
 }
 
+static std::string VK_CURRENT_DOWNLOAD_PATH = GetDefaultHomeDir();
+
+void SetDownloadPath(const std::string& path) { ::VK_CURRENT_DOWNLOAD_PATH = path; }
+
+static const std::string GetDownloadDir() {
+    std::string absolute_path = qgetenv("VK_DOWNLOAD").toStdString();
+
+    if (absolute_path.empty()) {  // Default path
+        absolute_path = VK_CURRENT_DOWNLOAD_PATH;
+    }
+
+    return absolute_path;
+}
+
 static const std::string GetAppDataDir() {
     const char* TABLE[] = {
         "/AppData/Local/LunarG",  // ENVIRONMENT_WIN32
@@ -392,6 +407,9 @@ Path::Path(Path::Builtin path) {
         case HOME:
             this->data = ::GetHomeDir();
             break;
+        case DOWNLOAD:
+            this->data = ::GetDownloadDir();
+            break;
         case DEFAULT_HOME:
             this->data = ::GetDefaultHomeDir();
             break;

vkconfig_core/path.h

@@ -28,6 +28,7 @@ class Path {
    public:
     enum Builtin {
         HOME,  // Vulkan SDK user directory
+        DOWNLOAD,
         DEFAULT_HOME,
         APPDATA,
         INIT,
@@ -69,6 +70,8 @@ class Path {
 
     bool Empty() const { return this->data.empty(); }
 
+    static const char* Separator();
+
    private:
     std::string data;
 
@@ -85,6 +88,8 @@ bool operator<(const Path& a, const Path& b);
 
 void SetHomePath(const std::string& path);
 
+void SetDownloadPath(const std::string& path);
+
 std::vector<Path> CollectFilePaths(const Path& directory, const char* filter = "*json");
 
 std::vector<std::string> CollectProfileNamesFromFile(const Path& profile_path);

vkconfig_core/test/test_version.cpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2020-2021 Valve Corporation
- * Copyright (c) 2020-2021 LunarG, Inc.
+ * Copyright (c) 2020-2025 Valve Corporation
+ * Copyright (c) 2020-2025 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,17 +27,148 @@
 TEST(test_version, string) {
     const std::string version_a("1.1.130");
     const std::string version_b("1.2.145");
+    const std::string version_c("1.3.298.0");
+    const std::string version_d("1.4");
 
     EXPECT_EQ(version_a, Version(version_a.c_str()).str());
     EXPECT_EQ(version_b, Version(version_b.c_str()).str());
+    EXPECT_EQ(version_c, Version(version_c.c_str()).str());
+    EXPECT_EQ(version_d, Version(version_d.c_str()).str());
 }
 
-TEST(test_version, string_ctr) { EXPECT_EQ(Version(1, 1, 130), Version("1.1.130")); }
+TEST(test_version, string_ctr) {
+    EXPECT_EQ(Version(2, 0), Version("2"));
+    EXPECT_EQ(Version(1, 4), Version("1.4"));
+    EXPECT_EQ(Version(1, 1, 130), Version("1.1.130"));
+    EXPECT_EQ(Version(1, 4, 304, 1), Version("1.4.304.1"));
+}
 
-TEST(test_version, compare) {
-    const std::string version_a("1.1.130");
-    const std::string version_b("1.2.135");
-    const std::string version_c("1.2.145");
+TEST(test_version, compare_2) {
+    const Version version_a("1.1");
+    const Version version_b("1.2");
+    const Version version_c("2.0");
+    const Version version_d("2.1");
+
+    EXPECT_TRUE(version_a == version_a);
+    EXPECT_TRUE(version_b == version_b);
+    EXPECT_TRUE(version_c == version_c);
+
+    EXPECT_TRUE(version_a != version_b);
+    EXPECT_TRUE(version_b != version_c);
+    EXPECT_TRUE(version_a != version_c);
+    EXPECT_TRUE(version_a != version_d);
+
+    EXPECT_TRUE(version_a < version_b);
+    EXPECT_TRUE(version_b < version_c);
+    EXPECT_TRUE(version_a < version_c);
+    EXPECT_TRUE(version_a < version_d);
+
+    EXPECT_TRUE(version_a <= version_a);
+    EXPECT_TRUE(version_b <= version_b);
+    EXPECT_TRUE(version_c <= version_c);
+    EXPECT_TRUE(version_d <= version_d);
+
+    EXPECT_TRUE(version_a <= version_b);
+    EXPECT_TRUE(version_b <= version_c);
+    EXPECT_TRUE(version_b <= version_d);
+    EXPECT_TRUE(version_c <= version_d);
+
+    EXPECT_TRUE(version_b > version_a);
+    EXPECT_TRUE(version_c > version_b);
+    EXPECT_TRUE(version_c > version_a);
+    EXPECT_TRUE(version_d > version_b);
+
+    EXPECT_TRUE(version_a >= version_a);
+    EXPECT_TRUE(version_b >= version_b);
+    EXPECT_TRUE(version_c >= version_c);
+    EXPECT_TRUE(version_d >= version_d);
+
+    EXPECT_TRUE(version_b >= version_a);
+    EXPECT_TRUE(version_c >= version_b);
+    EXPECT_TRUE(version_c >= version_a);
+    EXPECT_TRUE(version_d >= version_b);
+}
+
+TEST(test_version, compare_3) {
+    const Version version_a("1.1.130");
+    const Version version_b("1.2.135");
+    const Version version_c("1.2.145");
+
+    EXPECT_TRUE(version_a == version_a);
+    EXPECT_TRUE(version_b == version_b);
+    EXPECT_TRUE(version_c == version_c);
+
+    EXPECT_TRUE(version_a != version_b);
+    EXPECT_TRUE(version_b != version_c);
+    EXPECT_TRUE(version_a != version_c);
+
+    EXPECT_TRUE(version_a < version_b);
+    EXPECT_TRUE(version_b < version_c);
+    EXPECT_TRUE(version_a < version_c);
+
+    EXPECT_TRUE(version_a <= version_a);
+    EXPECT_TRUE(version_b <= version_b);
+    EXPECT_TRUE(version_c <= version_c);
+
+    EXPECT_TRUE(version_a <= version_b);
+    EXPECT_TRUE(version_b <= version_c);
+    EXPECT_TRUE(version_a <= version_c);
+
+    EXPECT_TRUE(version_b > version_a);
+    EXPECT_TRUE(version_c > version_b);
+    EXPECT_TRUE(version_c > version_a);
+
+    EXPECT_TRUE(version_a >= version_a);
+    EXPECT_TRUE(version_b >= version_b);
+    EXPECT_TRUE(version_c >= version_c);
+
+    EXPECT_TRUE(version_b >= version_a);
+    EXPECT_TRUE(version_c >= version_b);
+    EXPECT_TRUE(version_c >= version_a);
+}
+
+TEST(test_version, compare_4) {
+    const Version version_a("1.2.135.1");
+    const Version version_b("1.2.145.0");
+    const Version version_c("1.2.145.1");
+
+    EXPECT_TRUE(version_a == version_a);
+    EXPECT_TRUE(version_b == version_b);
+    EXPECT_TRUE(version_c == version_c);
+
+    EXPECT_TRUE(version_a != version_b);
+    EXPECT_TRUE(version_b != version_c);
+    EXPECT_TRUE(version_a != version_c);
+
+    EXPECT_TRUE(version_a < version_b);
+    EXPECT_TRUE(version_b < version_c);
+    EXPECT_TRUE(version_a < version_c);
+
+    EXPECT_TRUE(version_a <= version_a);
+    EXPECT_TRUE(version_b <= version_b);
+    EXPECT_TRUE(version_c <= version_c);
+
+    EXPECT_TRUE(version_a <= version_b);
+    EXPECT_TRUE(version_b <= version_c);
+    EXPECT_TRUE(version_a <= version_c);
+
+    EXPECT_TRUE(version_b > version_a);
+    EXPECT_TRUE(version_c > version_b);
+    EXPECT_TRUE(version_c > version_a);
+
+    EXPECT_TRUE(version_a >= version_a);
+    EXPECT_TRUE(version_b >= version_b);
+    EXPECT_TRUE(version_c >= version_c);
+
+    EXPECT_TRUE(version_b >= version_a);
+    EXPECT_TRUE(version_c >= version_b);
+    EXPECT_TRUE(version_c >= version_a);
+}
+
+TEST(test_version, compare_mix) {
+    const Version version_a("1.1");
+    const Version version_b("1.1.135");
+    const Version version_c("1.1.135.1");
 
     EXPECT_TRUE(version_a == version_a);
     EXPECT_TRUE(version_b == version_b);

vkconfig_core/type_platform.cpp

@@ -65,6 +65,8 @@ std::vector<std::string> GetPlatformTokens(int platform_flags) {
     return result;
 }
 
+bool IsDesktop(PlatformType type) { return type >= PLATFORM_DESKTOP_FIRST && type <= PLATFORM_DESKTOP_LAST; }
+
 bool IsPlatformSupported(int platform_flags) { return platform_flags & (1 << VKC_PLATFORM); }
 
 const char* GetLabel(PlatformType type) {
@@ -84,3 +86,51 @@ const char* GetLabel(PlatformType type) {
 
     return TABLE[type];
 }
+
+const char* GetLastReleaseSDK(PlatformType type) {
+    assert(IsDesktop(type));
+
+    static const char* TABLE[] = {
+        "https://vulkan.lunarg.com/sdk/latest/windows.txt",  // PLATFORM_WINDOWS_X86
+        "https://vulkan.lunarg.com/sdk/latest/warm.txt",     // PLATFORM_WINDOWS_ARM
+        "https://vulkan.lunarg.com/sdk/latest/linux.txt",    // PLATFORM_LINUX
+        "https://vulkan.lunarg.com/sdk/latest/mac.txt",      // PLATFORM_MACOS
+        "N/A",                                               // PLATFORM_ANDROID
+        "N/A",                                               // PLATFORM_IOS
+    };
+    static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
+
+    return TABLE[type];
+}
+
+const char* GetInstallerFilename(PlatformType type) {
+    assert(IsDesktop(type));
+
+    static const char* TABLE[] = {
+        "vulkan_sdk.exe",     // PLATFORM_WINDOWS_X86
+        "vulkan_sdk.exe",     // PLATFORM_WINDOWS_ARM
+        "vulkan_sdk.tar.xz",  // PLATFORM_LINUX
+        "vulkan_sdk.zip",     // PLATFORM_MACOS
+        "N/A",                // PLATFORM_ANDROID
+        "N/A",                // PLATFORM_IOS
+    };
+    static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
+
+    return TABLE[type];
+}
+
+const char* GetLastPackageSDK(PlatformType type) {
+    assert(IsDesktop(type));
+
+    static const char* TABLE[] = {
+        "https://sdk.lunarg.com/sdk/download/latest/windows/vulkan_sdk.exe",   // PLATFORM_WINDOWS_X86
+        "https://sdk.lunarg.com/sdk/download/latest/warm/vulkan_sdk.exe",      // PLATFORM_WINDOWS_ARM
+        "https://sdk.lunarg.com/sdk/download/latest/linux/vulkan_sdk.tar.xz",  // PLATFORM_LINUX
+        "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan_sdk.zip",       // PLATFORM_MACOS
+        "N/A",                                                                 // PLATFORM_ANDROID
+        "N/A",                                                                 // PLATFORM_IOS
+    };
+    static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
+
+    return TABLE[type];
+}

vkconfig_core/type_platform.h

@@ -45,7 +45,10 @@ enum PlatformType {
     PLATFORM_IOS = 5,
 
     PLATFORM_FIRST = PLATFORM_WINDOWS_X86,
-    PLATFORM_LAST = PLATFORM_IOS
+    PLATFORM_LAST = PLATFORM_IOS,
+
+    PLATFORM_DESKTOP_FIRST = PLATFORM_WINDOWS_X86,
+    PLATFORM_DESKTOP_LAST = PLATFORM_MACOS
 };
 
 enum { PLATFORM_COUNT = PLATFORM_LAST - PLATFORM_FIRST + 1 };
@@ -88,6 +91,14 @@ std::vector<std::string> GetPlatformTokens(int platform_flags);
 #error "Unknown platform"
 #endif
 
+bool IsDesktop(PlatformType type);
+
 bool IsPlatformSupported(int platform_flags);
 
 const char* GetLabel(PlatformType type);
+
+const char* GetLastReleaseSDK(PlatformType type);
+
+const char* GetLastPackageSDK(PlatformType type);
+
+const char* GetInstallerFilename(PlatformType type);

vkconfig_core/util.cpp

@@ -88,6 +88,18 @@ bool IsFloat(const std::string& s) {
     return std::regex_search(s, FRAME_REGEX);
 }
 
+std::size_t CountChar(const std::string& value, char c) {
+    std::size_t count = 0;
+
+    for (std::size_t i = 0, n = value.size(); i < n; ++i) {
+        if (value[i] == c) {
+            ++count;
+        }
+    }
+
+    return count;
+}
+
 void RemoveString(std::vector<std::string>& list, const std::string& value) {
     std::vector<std::string> new_list;
     new_list.reserve(list.size());

vkconfig_core/util.h

@@ -53,6 +53,8 @@ bool IsNumber(const std::string& s);
 
 bool IsFloat(const std::string& s);
 
+std::size_t CountChar(const std::string& value, char c);
+
 // Remove a value if it's present
 void RemoveString(std::vector<std::string>& list, const std::string& value);