Skip to content

Commit 0f8ddd1

Browse files
christophe-lunargchristophe-lunarg
committed
vkconfig: Add Vulkan SDK release detection
1 parent c98e976 commit 0f8ddd1

17 files changed

+786
-137
lines changed

‎vkconfig_core/configurator.cpp

+16
Original file line numberDiff line numberDiff line change
@@ -824,8 +824,17 @@ bool Configurator::Load() {
824824
const QJsonObject& json_object = json_interface_object.value(GetToken(TAB_PREFERENCES)).toObject();
825825

826826
this->use_layer_dev_mode = json_object.value("use_layer_dev_mode").toBool();
827+
this->latest_sdk_version = Version(json_object.value("latest_sdk_version").toString().toStdString().c_str());
828+
829+
if (json_object.value("use_notify_releases") != QJsonValue::Undefined) {
830+
this->use_notify_releases = json_object.value("use_notify_releases").toBool();
831+
}
832+
827833
this->use_system_tray = json_object.value("use_system_tray").toBool();
828834
::SetHomePath(json_object.value("VK_HOME").toString().toStdString());
835+
if (json_object.value("VK_DOWNLOAD") != QJsonValue::Undefined) {
836+
::SetDownloadPath(json_object.value("VK_DOWNLOAD").toString().toStdString());
837+
}
829838
}
830839

831840
this->executables.Load(json_root_object);
@@ -873,7 +882,10 @@ bool Configurator::Save() const {
873882
QJsonObject json_object;
874883
json_object.insert("use_system_tray", this->use_system_tray);
875884
json_object.insert("use_layer_dev_mode", this->use_layer_dev_mode);
885+
json_object.insert("use_notify_releases", this->use_notify_releases);
886+
json_object.insert("latest_sdk_version", this->latest_sdk_version.str().c_str());
876887
json_object.insert("VK_HOME", ::Path(Path::HOME).RelativePath().c_str());
888+
json_object.insert("VK_DOWNLOAD", ::Path(Path::DOWNLOAD).RelativePath().c_str());
877889
json_interface_object.insert(GetToken(TAB_PREFERENCES), json_object);
878890
}
879891

@@ -933,6 +945,10 @@ bool Configurator::GetUseLayerDevMode() const { return this->use_layer_dev_mode;
933945

934946
void Configurator::SetUseLayerDevMode(bool enabled) { this->use_layer_dev_mode = enabled; }
935947

948+
bool Configurator::GetUseNotifyReleases() const { return this->use_notify_releases; }
949+
950+
void Configurator::SetUseNotifyReleases(bool enabled) { this->use_notify_releases = enabled; }
951+
936952
bool Configurator::HasActiveSettings() const {
937953
switch (this->executable_scope) {
938954
default:

‎vkconfig_core/configurator.h

+6
Original file line numberDiff line numberDiff line change
@@ -109,6 +109,9 @@ class Configurator {
109109
bool GetUseLayerDevMode() const;
110110
void SetUseLayerDevMode(bool enabled);
111111

112+
bool GetUseNotifyReleases() const;
113+
void SetUseNotifyReleases(bool enabled);
114+
112115
bool HasActiveSettings() const;
113116
bool HasEnabledUI(EnabledUI enabled_ui) const;
114117

@@ -136,11 +139,14 @@ class Configurator {
136139
TabType active_tab = TAB_CONFIGURATIONS;
137140
bool advanced = true;
138141
Path last_path_status = Path(Path::HOME).RelativePath() + "/vkconfig.txt";
142+
Version latest_sdk_version = Version::VKHEADER;
143+
Version online_sdk_version = Version::NONE;
139144

140145
private:
141146
int hide_message_boxes_flags = 0;
142147
bool use_system_tray = false;
143148
bool use_layer_dev_mode = false;
149+
bool use_notify_releases = true;
144150
ExecutableScope executable_scope = EXECUTABLE_ANY;
145151
std::string selected_global_configuration = "Validation";
146152
};

‎vkconfig_core/path.cpp

+23-5
Original file line numberDiff line numberDiff line change
@@ -38,9 +38,10 @@ struct BuiltinDesc {
3838
const Path::Builtin path;
3939
};
4040

41-
static const BuiltinDesc VARIABLES[] = {
42-
{"${VK_HOME}", Path::HOME}, {"${VK_APPDATA}", Path::APPDATA}, {"${VULKAN_BIN}", Path::BIN},
43-
{"${VULKAN_SDK}", Path::SDK}, {"${VULKAN_PROFILES}", Path::PROFILES}, {"${VULKAN_CONTENT}", Path::CONTENT}};
41+
static const BuiltinDesc VARIABLES[] = {{"${VK_HOME}", Path::HOME}, {"${VK_DOWNLOAD}", Path::DOWNLOAD},
42+
{"${VK_APPDATA}", Path::APPDATA}, {"${VULKAN_BIN}", Path::BIN},
43+
{"${VULKAN_SDK}", Path::SDK}, {"${VULKAN_PROFILES}", Path::PROFILES},
44+
{"${VULKAN_CONTENT}", Path::CONTENT}};
4445

4546
static std::string ConvertSeparators(const std::string& path, const char* native_separator, const char* alien_separator) {
4647
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
7475
return current_path;
7576
}
7677

77-
static const char* GetNativeSeparator() {
78+
const char* Path::Separator() {
7879
static const char* native_separator = VKC_ENV == VKC_ENV_WIN32 ? "\\" : "/";
7980
return native_separator;
8081
}
8182

8283
static std::string ConvertNativeSeparators(const std::string& path) {
83-
const char* native_separator = GetNativeSeparator();
84+
const char* native_separator = Path::Separator();
8485
const char* alien_separator = VKC_ENV != VKC_ENV_WIN32 ? "\\" : "/";
8586

8687
return ConvertSeparators(path, native_separator, alien_separator);
@@ -247,6 +248,20 @@ static const std::string GetHomeDir() {
247248
return absolute_path;
248249
}
249250

251+
static std::string VK_CURRENT_DOWNLOAD_PATH = GetDefaultHomeDir() + "/Releases";
252+
253+
void SetDownloadPath(const std::string& path) { ::VK_CURRENT_DOWNLOAD_PATH = path; }
254+
255+
static const std::string GetDownloadDir() {
256+
std::string absolute_path = qgetenv("VK_DOWNLOAD").toStdString();
257+
258+
if (absolute_path.empty()) { // Default path
259+
absolute_path = VK_CURRENT_DOWNLOAD_PATH;
260+
}
261+
262+
return absolute_path;
263+
}
264+
250265
static const std::string GetAppDataDir() {
251266
const char* TABLE[] = {
252267
"/AppData/Local/LunarG", // ENVIRONMENT_WIN32
@@ -392,6 +407,9 @@ Path::Path(Path::Builtin path) {
392407
case HOME:
393408
this->data = ::GetHomeDir();
394409
break;
410+
case DOWNLOAD:
411+
this->data = ::GetDownloadDir();
412+
break;
395413
case DEFAULT_HOME:
396414
this->data = ::GetDefaultHomeDir();
397415
break;

‎vkconfig_core/path.h

+5
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ class Path {
2828
public:
2929
enum Builtin {
3030
HOME, // Vulkan SDK user directory
31+
DOWNLOAD,
3132
DEFAULT_HOME,
3233
APPDATA,
3334
INIT,
@@ -69,6 +70,8 @@ class Path {
6970

7071
bool Empty() const { return this->data.empty(); }
7172

73+
static const char* Separator();
74+
7275
private:
7376
std::string data;
7477

@@ -85,6 +88,8 @@ bool operator<(const Path& a, const Path& b);
8588

8689
void SetHomePath(const std::string& path);
8790

91+
void SetDownloadPath(const std::string& path);
92+
8893
std::vector<Path> CollectFilePaths(const Path& directory, const char* filter = "*json");
8994

9095
std::vector<std::string> CollectProfileNamesFromFile(const Path& profile_path);

‎vkconfig_core/test/test_version.cpp

+138-7
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
/*
2-
* Copyright (c) 2020-2021 Valve Corporation
3-
* Copyright (c) 2020-2021 LunarG, Inc.
2+
* Copyright (c) 2020-2025 Valve Corporation
3+
* Copyright (c) 2020-2025 LunarG, Inc.
44
*
55
* Licensed under the Apache License, Version 2.0 (the "License");
66
* you may not use this file except in compliance with the License.
@@ -27,17 +27,148 @@
2727
TEST(test_version, string) {
2828
const std::string version_a("1.1.130");
2929
const std::string version_b("1.2.145");
30+
const std::string version_c("1.3.298.0");
31+
const std::string version_d("1.4");
3032

3133
EXPECT_EQ(version_a, Version(version_a.c_str()).str());
3234
EXPECT_EQ(version_b, Version(version_b.c_str()).str());
35+
EXPECT_EQ(version_c, Version(version_c.c_str()).str());
36+
EXPECT_EQ(version_d, Version(version_d.c_str()).str());
3337
}
3438

35-
TEST(test_version, string_ctr) { EXPECT_EQ(Version(1, 1, 130), Version("1.1.130")); }
39+
TEST(test_version, string_ctr) {
40+
EXPECT_EQ(Version(2, 0), Version("2"));
41+
EXPECT_EQ(Version(1, 4), Version("1.4"));
42+
EXPECT_EQ(Version(1, 1, 130), Version("1.1.130"));
43+
EXPECT_EQ(Version(1, 4, 304, 1), Version("1.4.304.1"));
44+
}
3645

37-
TEST(test_version, compare) {
38-
const std::string version_a("1.1.130");
39-
const std::string version_b("1.2.135");
40-
const std::string version_c("1.2.145");
46+
TEST(test_version, compare_2) {
47+
const Version version_a("1.1");
48+
const Version version_b("1.2");
49+
const Version version_c("2.0");
50+
const Version version_d("2.1");
51+
52+
EXPECT_TRUE(version_a == version_a);
53+
EXPECT_TRUE(version_b == version_b);
54+
EXPECT_TRUE(version_c == version_c);
55+
56+
EXPECT_TRUE(version_a != version_b);
57+
EXPECT_TRUE(version_b != version_c);
58+
EXPECT_TRUE(version_a != version_c);
59+
EXPECT_TRUE(version_a != version_d);
60+
61+
EXPECT_TRUE(version_a < version_b);
62+
EXPECT_TRUE(version_b < version_c);
63+
EXPECT_TRUE(version_a < version_c);
64+
EXPECT_TRUE(version_a < version_d);
65+
66+
EXPECT_TRUE(version_a <= version_a);
67+
EXPECT_TRUE(version_b <= version_b);
68+
EXPECT_TRUE(version_c <= version_c);
69+
EXPECT_TRUE(version_d <= version_d);
70+
71+
EXPECT_TRUE(version_a <= version_b);
72+
EXPECT_TRUE(version_b <= version_c);
73+
EXPECT_TRUE(version_b <= version_d);
74+
EXPECT_TRUE(version_c <= version_d);
75+
76+
EXPECT_TRUE(version_b > version_a);
77+
EXPECT_TRUE(version_c > version_b);
78+
EXPECT_TRUE(version_c > version_a);
79+
EXPECT_TRUE(version_d > version_b);
80+
81+
EXPECT_TRUE(version_a >= version_a);
82+
EXPECT_TRUE(version_b >= version_b);
83+
EXPECT_TRUE(version_c >= version_c);
84+
EXPECT_TRUE(version_d >= version_d);
85+
86+
EXPECT_TRUE(version_b >= version_a);
87+
EXPECT_TRUE(version_c >= version_b);
88+
EXPECT_TRUE(version_c >= version_a);
89+
EXPECT_TRUE(version_d >= version_b);
90+
}
91+
92+
TEST(test_version, compare_3) {
93+
const Version version_a("1.1.130");
94+
const Version version_b("1.2.135");
95+
const Version version_c("1.2.145");
96+
97+
EXPECT_TRUE(version_a == version_a);
98+
EXPECT_TRUE(version_b == version_b);
99+
EXPECT_TRUE(version_c == version_c);
100+
101+
EXPECT_TRUE(version_a != version_b);
102+
EXPECT_TRUE(version_b != version_c);
103+
EXPECT_TRUE(version_a != version_c);
104+
105+
EXPECT_TRUE(version_a < version_b);
106+
EXPECT_TRUE(version_b < version_c);
107+
EXPECT_TRUE(version_a < version_c);
108+
109+
EXPECT_TRUE(version_a <= version_a);
110+
EXPECT_TRUE(version_b <= version_b);
111+
EXPECT_TRUE(version_c <= version_c);
112+
113+
EXPECT_TRUE(version_a <= version_b);
114+
EXPECT_TRUE(version_b <= version_c);
115+
EXPECT_TRUE(version_a <= version_c);
116+
117+
EXPECT_TRUE(version_b > version_a);
118+
EXPECT_TRUE(version_c > version_b);
119+
EXPECT_TRUE(version_c > version_a);
120+
121+
EXPECT_TRUE(version_a >= version_a);
122+
EXPECT_TRUE(version_b >= version_b);
123+
EXPECT_TRUE(version_c >= version_c);
124+
125+
EXPECT_TRUE(version_b >= version_a);
126+
EXPECT_TRUE(version_c >= version_b);
127+
EXPECT_TRUE(version_c >= version_a);
128+
}
129+
130+
TEST(test_version, compare_4) {
131+
const Version version_a("1.2.135.1");
132+
const Version version_b("1.2.145.0");
133+
const Version version_c("1.2.145.1");
134+
135+
EXPECT_TRUE(version_a == version_a);
136+
EXPECT_TRUE(version_b == version_b);
137+
EXPECT_TRUE(version_c == version_c);
138+
139+
EXPECT_TRUE(version_a != version_b);
140+
EXPECT_TRUE(version_b != version_c);
141+
EXPECT_TRUE(version_a != version_c);
142+
143+
EXPECT_TRUE(version_a < version_b);
144+
EXPECT_TRUE(version_b < version_c);
145+
EXPECT_TRUE(version_a < version_c);
146+
147+
EXPECT_TRUE(version_a <= version_a);
148+
EXPECT_TRUE(version_b <= version_b);
149+
EXPECT_TRUE(version_c <= version_c);
150+
151+
EXPECT_TRUE(version_a <= version_b);
152+
EXPECT_TRUE(version_b <= version_c);
153+
EXPECT_TRUE(version_a <= version_c);
154+
155+
EXPECT_TRUE(version_b > version_a);
156+
EXPECT_TRUE(version_c > version_b);
157+
EXPECT_TRUE(version_c > version_a);
158+
159+
EXPECT_TRUE(version_a >= version_a);
160+
EXPECT_TRUE(version_b >= version_b);
161+
EXPECT_TRUE(version_c >= version_c);
162+
163+
EXPECT_TRUE(version_b >= version_a);
164+
EXPECT_TRUE(version_c >= version_b);
165+
EXPECT_TRUE(version_c >= version_a);
166+
}
167+
168+
TEST(test_version, compare_mix) {
169+
const Version version_a("1.1");
170+
const Version version_b("1.1.135");
171+
const Version version_c("1.1.135.1");
41172

42173
EXPECT_TRUE(version_a == version_a);
43174
EXPECT_TRUE(version_b == version_b);

‎vkconfig_core/type_platform.cpp

+66
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,8 @@ std::vector<std::string> GetPlatformTokens(int platform_flags) {
6565
return result;
6666
}
6767

68+
bool IsDesktop(PlatformType type) { return type >= PLATFORM_DESKTOP_FIRST && type <= PLATFORM_DESKTOP_LAST; }
69+
6870
bool IsPlatformSupported(int platform_flags) { return platform_flags & (1 << VKC_PLATFORM); }
6971

7072
const char* GetLabel(PlatformType type) {
@@ -84,3 +86,67 @@ const char* GetLabel(PlatformType type) {
8486

8587
return TABLE[type];
8688
}
89+
90+
const char* GetLatestReleaseSDK(PlatformType type) {
91+
assert(IsDesktop(type));
92+
93+
static const char* TABLE[] = {
94+
"https://vulkan.lunarg.com/sdk/latest/windows.txt", // PLATFORM_WINDOWS_X86
95+
"https://vulkan.lunarg.com/sdk/latest/warm.txt", // PLATFORM_WINDOWS_ARM
96+
"https://vulkan.lunarg.com/sdk/latest/linux.txt", // PLATFORM_LINUX
97+
"https://vulkan.lunarg.com/sdk/latest/mac.txt", // PLATFORM_MACOS
98+
"N/A", // PLATFORM_ANDROID
99+
"N/A", // PLATFORM_IOS
100+
};
101+
static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
102+
103+
return TABLE[type];
104+
}
105+
106+
const char* GetInstallerFilename(PlatformType type) {
107+
assert(IsDesktop(type));
108+
109+
static const char* TABLE[] = {
110+
"vulkan_sdk.exe", // PLATFORM_WINDOWS_X86
111+
"vulkan_sdk.exe", // PLATFORM_WINDOWS_ARM
112+
"vulkan_sdk.tar.xz", // PLATFORM_LINUX
113+
"vulkan_sdk.zip", // PLATFORM_MACOS
114+
"N/A", // PLATFORM_ANDROID
115+
"N/A", // PLATFORM_IOS
116+
};
117+
static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
118+
119+
return TABLE[type];
120+
}
121+
122+
const char* GetVersionedFilename(PlatformType type) {
123+
assert(IsDesktop(type));
124+
125+
static const char* TABLE[] = {
126+
"vulkan_sdk-%s.exe", // PLATFORM_WINDOWS_X86
127+
"vulkan_sdk-%s.exe", // PLATFORM_WINDOWS_ARM
128+
"vulkan_sdk-%s.tar.xz", // PLATFORM_LINUX
129+
"vulkan_sdk-%s.zip", // PLATFORM_MACOS
130+
"N/A", // PLATFORM_ANDROID
131+
"N/A", // PLATFORM_IOS
132+
};
133+
static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
134+
135+
return TABLE[type];
136+
}
137+
138+
const char* GetLatestPackageSDK(PlatformType type) {
139+
assert(IsDesktop(type));
140+
141+
static const char* TABLE[] = {
142+
"https://sdk.lunarg.com/sdk/download/latest/windows/vulkan_sdk.exe", // PLATFORM_WINDOWS_X86
143+
"https://sdk.lunarg.com/sdk/download/latest/warm/vulkan_sdk.exe", // PLATFORM_WINDOWS_ARM
144+
"https://sdk.lunarg.com/sdk/download/latest/linux/vulkan_sdk.tar.xz", // PLATFORM_LINUX
145+
"https://sdk.lunarg.com/sdk/download/latest/mac/vulkan_sdk.zip", // PLATFORM_MACOS
146+
"N/A", // PLATFORM_ANDROID
147+
"N/A", // PLATFORM_IOS
148+
};
149+
static_assert(std::size(TABLE) == PLATFORM_COUNT, "The tranlation table size doesn't match the enum number of elements");
150+
151+
return TABLE[type];
152+
}

0 commit comments

Comments
 (0)