diff --git a/vkconfig_core/configuration.cpp b/vkconfig_core/configuration.cpp index fd085aff39..747da62ac5 100644 --- a/vkconfig_core/configuration.cpp +++ b/vkconfig_core/configuration.cpp @@ -475,7 +475,7 @@ void Configuration::GatherParameters(const LayerManager& layers) { gathered_parameters.push_back(parameter); } - const std::vector& list = layers.BuildLayerNameList(); + const std::vector& list = layers.GatherLayerNames(); for (std::size_t i = 0, n = list.size(); i < n; ++i) { const Layer* layer = layers.Find(list[i], Version::LATEST); diff --git a/vkconfig_core/configuration_manager.cpp b/vkconfig_core/configuration_manager.cpp index f0eff06c16..72dd2ddc29 100644 --- a/vkconfig_core/configuration_manager.cpp +++ b/vkconfig_core/configuration_manager.cpp @@ -154,7 +154,7 @@ void ConfigurationManager::SortConfigurations() { std::vector ConfigurationManager::BuildReferencedLayers(const LayerManager &layers, const Path &path) { std::vector result; - layers.BuildLayerNameList(); + layers.GatherLayerNames(); return result; } diff --git a/vkconfig_core/configurator.cpp b/vkconfig_core/configurator.cpp index fc31572600..764f47b8ee 100644 --- a/vkconfig_core/configurator.cpp +++ b/vkconfig_core/configurator.cpp @@ -22,7 +22,6 @@ #include "configurator.h" #include "registry.h" -#include "vulkan_info.h" #include "util.h" #include "path.h" #include "alert.h" @@ -471,7 +470,7 @@ bool Configurator::Surrender(OverrideArea override_area) { } #if VKC_ENV == VKC_ENV_WIN32 - RemoveRegistryEntriesForLayers(loader_settings_path.AbsolutePath().c_str(), layers_settings_path.AbsolutePath().c_str()); + RemoveRegistryEntriesForLayers(); #endif return result_loader_settings && result_layers_settings; @@ -602,16 +601,122 @@ void Configurator::Reset() { std::string Configurator::Log() const { std::string log; - log += format("## %s %s - %s\n", VKCONFIG_NAME, Version::VKCONFIG.str().c_str(), GetBuildDate().c_str()); - #ifdef _DEBUG std::string build = "Debug"; #else std::string build = "Release"; #endif - log += format("- Build: %s %s\n", GetLabel(VKC_PLATFORM), build.c_str()); - log += format("- Vulkan API version: %s\n", Version::VKHEADER.str().c_str()); + log += format("%s %s - %s:\n", VKCONFIG_NAME, Version::VKCONFIG.str().c_str(), GetBuildDate().c_str()); + log += format(" - Build: %s %s\n", GetLabel(VKC_PLATFORM), build.c_str()); + log += format(" - Vulkan API version: %s\n", Version::VKHEADER.str().c_str()); + log += format(" - ${VULKAN_SDK}: %s\n", ::Get(Path::SDK).AbsolutePath().c_str()); + log += "\n"; + + log += format("%s Settings:\n", VKCONFIG_NAME); + log += format(" - Use system tray: %s\n", this->use_system_tray ? "true" : "false"); + log += format(" - ${VK_HOME}: %s\n", this->home_sdk_path.AbsolutePath().c_str()); + log += format(" - Vulkan Loader and Layers system files:\n"); + log += format(" * %s\n", ::Get(Path::LOADER_SETTINGS).AbsolutePath().c_str()); + log += format(" * %s\n", ::Get(Path::LAYERS_SETTINGS).AbsolutePath().c_str()); + log += "\n"; + + log += "Vulkan Physical Devices:\n"; + for (std::size_t i = 0, n = this->vulkan_system_info.physicalDevices.size(); i < n; ++i) { + const VulkanPhysicalDeviceInfo& info = this->vulkan_system_info.physicalDevices[i]; + log += format(" - %s with Vulkan %s (%s)\n", info.deviceName.c_str(), info.apiVersion.str().c_str(), + GetLabel(info.deviceType)); + if (info.vendorID == 0x10DE) { + log += format(" * Driver: %s %s\n", GetLabel(info.vendorID).c_str(), FormatNvidia(info.driverVersion).c_str()); + } else if ((info.vendorID == 0x8086) && (VKC_PLATFORM & PLATFORM_WINDOWS_BIT)) { + log += format(" * Driver: %s %s\n", GetLabel(info.vendorID).c_str(), FormatIntelWindows(info.driverVersion).c_str()); + } else { + log += format(" * Driver: %s %s\n", GetLabel(info.vendorID).c_str(), Version(info.driverVersion).str().c_str()); + } + log += format(" * deviceUUID: %s\n", info.deviceUUID.c_str()); + log += format(" * driverUUID: %s\n", info.driverUUID.c_str()); + log += format(" * deviceLUID: %s\n", info.deviceLUID.c_str()); + } + log += "\n"; + + log += "Vulkan Loader Settings:\n"; + if (this->vulkan_system_info.loaderVersion != Version::NONE) { + log += format(" - API version: %s\n", this->vulkan_system_info.loaderVersion.str().c_str()); + } else { + log += format(" - Couldn't Find a Vulkan Loader\n"); + } + + log += " - Vulkan Loader found Vulkan layers:\n"; + for (std::size_t i = 0, n = this->vulkan_system_info.instanceLayerProperties.size(); i < n; ++i) { + log += format(" * %s\n", this->vulkan_system_info.instanceLayerProperties[i].layerName); + } + log += " - Vulkan implementation or by implicitly enabled layers extensions:\n"; + for (std::size_t i = 0, n = this->vulkan_system_info.instanceExtensionPropertie.size(); i < n; ++i) { + log += format(" * %s\n", this->vulkan_system_info.instanceExtensionPropertie[i].extensionName); + } + + if (qEnvironmentVariableIsSet("VK_LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING")) { + log += format(" - ${VK_LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING}: %s\n", + qgetenv("VK_LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING").toStdString().c_str()); + } else { + log += " - ${VK_LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING}: unset\n"; + } + + log += " - Vulkan Loader Layers environment variables:\n"; + if (qEnvironmentVariableIsSet("VK_LOADER_DEBUG")) { + log += format(" * ${VK_LOADER_DEBUG}: %s\n", qgetenv("VK_LOADER_DEBUG").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_DEBUG}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_LOADER_LAYERS_ENABLE")) { + log += format(" * ${VK_LOADER_LAYERS_ENABLE}: %s\n", qgetenv("VK_LOADER_LAYERS_ENABLE").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_LAYERS_ENABLE}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_LOADER_LAYERS_DISABLE")) { + log += format(" * ${VK_LOADER_LAYERS_DISABLE}: %s\n", qgetenv("VK_LOADER_LAYERS_DISABLE").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_LAYERS_DISABLE}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_LOADER_LAYERS_ALLOW")) { + log += format(" * ${VK_LOADER_LAYERS_ALLOW}: %s\n", qgetenv("VK_LOADER_LAYERS_ALLOW").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_LAYERS_ALLOW}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_INSTANCE_LAYERS")) { + log += format(" * ${VK_INSTANCE_LAYERS}: %s\n", qgetenv("VK_INSTANCE_LAYERS").toStdString().c_str()); + } + log += " - Vulkan Loader Drivers environment variables:\n"; + if (qEnvironmentVariableIsSet("VK_DRIVER_FILES")) { + log += format(" * ${VK_DRIVER_FILES}: %s\n", qgetenv("VK_DRIVER_FILES").toStdString().c_str()); + } else { + log += " * ${VK_DRIVER_FILES}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_ADD_DRIVER_FILES")) { + log += format(" * ${VK_ADD_DRIVER_FILES}: %s\n", qgetenv("VK_ADD_DRIVER_FILES").toStdString().c_str()); + } else { + log += " * ${VK_ADD_DRIVER_FILES}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_LOADER_DRIVERS_SELECT")) { + log += format(" * ${VK_LOADER_DRIVERS_SELECT}: %s\n", qgetenv("VK_LOADER_DRIVERS_SELECT").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_DRIVERS_SELECT}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_LOADER_DRIVERS_DISABLE")) { + log += format(" * ${VK_LOADER_DRIVERS_DISABLE}: %s\n", qgetenv("VK_LOADER_DRIVERS_DISABLE").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_DRIVERS_DISABLE}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_LOADER_DISABLE_INST_EXT_FILTER")) { + log += format(" * ${VK_LOADER_DISABLE_INST_EXT_FILTER}: %s\n", + qgetenv("VK_LOADER_DISABLE_INST_EXT_FILTER").toStdString().c_str()); + } else { + log += " * ${VK_LOADER_DISABLE_INST_EXT_FILTER}: unset\n"; + } + if (qEnvironmentVariableIsSet("VK_ICD_FILENAMES")) { + log += format(" * ${VK_ICD_FILENAMES}: %s\n", qgetenv("VK_ICD_FILENAMES").toStdString().c_str()); + } + log += "\n"; return log; } @@ -800,60 +905,6 @@ std::string Configurator::GenerateVulkanStatus() const { log += "- Environment variables:\n"; - // Check Vulkan SDK path - if (Get(Path::SDK).Empty()) - log += " - ${VULKAN_SDK} not set\n"; - else - log += format(" - ${VULKAN_SDK}: %s\n", AbsolutePath(Path::SDK).c_str()); - - // Check VK_HOME path - if (!Get(Path::HOME).Empty()) { - log += format(" - ${VK_HOME}: %s\n", AbsolutePath(Path::HOME).c_str()); - } - - const Version loader_version = GetVulkanLoaderVersion(); - - if (loader_version == Version::VERSION_NULL) { - Alert::LoaderFailure(); - - log += "- Could not find a Vulkan Loader.\n"; - return log; - } else { - log += format("- Vulkan Loader version: %s\n", loader_version.str().c_str()); - const LogFlags log_flags = configurator.environment.GetLoaderMessageFlags(); - if (log_flags != 0) { - log += format(" - ${VK_LOADER_DEBUG}=%s\n", GetLogString(log_flags).c_str()); - } - } - - log += "- User-Defined Layers locations:\n"; - log += GetUserDefinedLayersPathsLog("${VK_LAYER_PATH} variable", USER_DEFINED_LAYERS_PATHS_ENV_SET); - log += GetUserDefinedLayersPathsLog("Per-configuration paths", USER_DEFINED_LAYERS_PATHS_GUI); - log += GetUserDefinedLayersPathsLog("${VK_ADD_LAYER_PATH} variable", USER_DEFINED_LAYERS_PATHS_ENV_ADD); - - // vk_layer_settings.txt - const Path layer_settings_path(qgetenv("VK_LAYER_SETTINGS_PATH").toStdString()); - if (!layer_settings_path.Empty()) { - log += "- `vk_layer_settings.txt` location overridden by VK_LAYER_SETTINGS_PATH:\n"; - if (layer_settings_path.RelativePath().find("vk_layer_settings.txt") == std::string::npos) { - log += format(" %s\n", layer_settings_path.RelativePath().c_str()); - } else { - log += format(" %s\n", layer_settings_path.AbsoluteDir().c_str()); - } - } else { - log += "- `vk_layer_settings.txt` uses the default platform path:\n"; - log += format(" %s\n", AbsolutePath(Path::LAYERS_SETTINGS).c_str()); - } - - // vk_loader_settings.json - log += "- `vk_loader_settings.json` uses the default platform path:\n"; - log += format(" %s\n", AbsolutePath(Path::LOADER_SETTINGS).c_str()); - - // If there is no Vulkan loader installed, we can't call any Vulkan API. - if (loader_version == Version::VERSION_NULL) { - return log; - } - LayersMode saved_mode = configurator.environment.GetMode(); configurator.environment.SetMode(LAYERS_CONTROLLED_BY_APPLICATIONS); configurator.Configure(configurator.layers.selected_layers); diff --git a/vkconfig_core/configurator.h b/vkconfig_core/configurator.h index 3271813213..da267b1554 100644 --- a/vkconfig_core/configurator.h +++ b/vkconfig_core/configurator.h @@ -22,6 +22,7 @@ #pragma once #include "version.h" +#include "vulkan_util.h" #include "configuration_manager.h" #include "configuration_manager.h" #include "layer_manager.h" @@ -31,7 +32,6 @@ #include "type_hide_message.h" #include "type_tab.h" #include "type_executable_mode.h" -#include "vulkan_info.h" #include "serialization.h" class Configurator : public Serialize { diff --git a/vkconfig_core/layer.h b/vkconfig_core/layer.h index 3a45c60be6..389ff3029d 100644 --- a/vkconfig_core/layer.h +++ b/vkconfig_core/layer.h @@ -1,6 +1,6 @@ /* - * Copyright (c) 2020-2021 Valve Corporation - * Copyright (c) 2020-2021 LunarG, Inc. + * Copyright (c) 2020-2024 Valve Corporation + * Copyright (c) 2020-2024 LunarG, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/vkconfig_core/layer_manager.cpp b/vkconfig_core/layer_manager.cpp index 5a0839ba6f..4fcdbaecbe 100644 --- a/vkconfig_core/layer_manager.cpp +++ b/vkconfig_core/layer_manager.cpp @@ -25,6 +25,22 @@ #include +std::vector GetEnvVariablePaths(const char *variable_name, LayerType type) { + std::vector result; + + const char *SEPARATOR = GetToken(PARSE_ENV_VAR); + + const std::vector &paths = UniqueStrings(Split(qgetenv(variable_name).toStdString(), SEPARATOR)); + result.resize(paths.size()); + for (std::size_t i = 0, n = paths.size(); i < n; ++i) { + result[i].path = paths[i]; + result[i].enabled = true; + result[i].type = type; + } + + return result; +} + std::vector GetImplicitLayerPaths() { std::vector result; @@ -203,6 +219,36 @@ void LayerManager::Reset() { std::string LayerManager::Log() const { std::string log; + + log += "Vulkan Layers Locations\n"; + + for (std::size_t group_index = 0, group_count = this->paths.size(); group_index < group_count; ++group_index) { + const std::vector &paths_group = this->paths[group_index]; + if (paths_group.empty()) { + log += format(" %d. %s paths:\n", group_index + 1, ::GetLabel(static_cast(group_index))); + log += format(" - None\n"); + } else { + log += format(" %d. %s paths:\n", group_index + 1, ::GetLabel(static_cast(group_index))); + } + + for (std::size_t path_index = 0, path_count = paths_group.size(); path_index < path_count; ++path_index) { + log += format(" - %s (%s)\n", paths_group[path_index].path.AbsolutePath().c_str(), + paths_group[path_index].enabled ? "enabled" : "disabled"); + + const std::vector layers = this->GatherLayers(paths_group[path_index]); + + for (std::size_t i = 0, n = layers.size(); i < n; ++i) { + log += format(" * %s - %s", layers[i]->key.c_str(), layers[i]->api_version.str().c_str()); + if (layers[i]->status != STATUS_STABLE) { + log += format(" (%s)", GetToken(layers[i]->status)); + } + log += "\n"; + } + } + } + + log += "\n"; + return log; } @@ -210,32 +256,22 @@ void LayerManager::InitSystemPaths() { this->selected_layers.clear(); this->layers_validated.clear(); - this->paths[LAYERS_PATHS_IMPLICIT] = GetImplicitLayerPaths(); + this->paths[LAYERS_PATHS_IMPLICIT_SYSTEM] = GetImplicitLayerPaths(); - this->paths[LAYERS_PATHS_EXPLICIT] = GetExplicitLayerPaths(); + // LAYERS_PATHS_IMPLICIT_ENV_SET: VK_IMPLICIT_LAYER_PATH env variables + this->paths[LAYERS_PATHS_IMPLICIT_ENV_SET] = GetEnvVariablePaths("VK_IMPLICIT_LAYER_PATH", LAYER_TYPE_IMPLICIT); - const char *SEPARATOR = GetToken(PARSE_ENV_VAR); + // LAYERS_PATHS_IMPLICIT_ENV_ADD: VK_ADD_IMPLICIT_LAYER_PATH env variables + this->paths[LAYERS_PATHS_IMPLICIT_ENV_ADD] = GetEnvVariablePaths("VK_ADD_IMPLICIT_LAYER_PATH", LAYER_TYPE_IMPLICIT); - // LAYERS_PATHS_ENV_SET: VK_LAYER_PATH env variables - { - const std::vector &VK_LAYER_PATH = UniqueStrings(Split(qgetenv("VK_LAYER_PATH").toStdString(), SEPARATOR)); - this->paths[LAYERS_PATHS_ENV_SET].resize(VK_LAYER_PATH.size()); - for (std::size_t i = 0, n = VK_LAYER_PATH.size(); i < n; ++i) { - this->paths[LAYERS_PATHS_ENV_SET][i].path = VK_LAYER_PATH[i]; - this->paths[LAYERS_PATHS_ENV_SET][i].enabled = true; - } - } + // LAYERS_PATHS_EXPLICIT_SYSTEM + this->paths[LAYERS_PATHS_EXPLICIT_SYSTEM] = GetExplicitLayerPaths(); - // LAYERS_PATHS_ENV_ADD: VK_ADD_LAYER_PATH env variables - { - const std::vector &VK_ADD_LAYER_PATH = - UniqueStrings(Split(qgetenv("VK_ADD_LAYER_PATH").toStdString(), SEPARATOR)); - this->paths[LAYERS_PATHS_ENV_ADD].resize(VK_ADD_LAYER_PATH.size()); - for (std::size_t i = 0, n = VK_ADD_LAYER_PATH.size(); i < n; ++i) { - this->paths[LAYERS_PATHS_ENV_ADD][i].path = VK_ADD_LAYER_PATH[i]; - this->paths[LAYERS_PATHS_ENV_ADD][i].enabled = true; - } - } + // LAYERS_PATHS_EXPLICIT_ENV_SET: VK_LAYER_PATH env variables + this->paths[LAYERS_PATHS_EXPLICIT_ENV_SET] = GetEnvVariablePaths("VK_LAYER_PATH", LAYER_TYPE_EXPLICIT); + + // LAYERS_PATHS_EXPLICIT_ENV_ADD: VK_ADD_LAYER_PATH env variables + this->paths[LAYERS_PATHS_EXPLICIT_ENV_ADD] = GetEnvVariablePaths("VK_ADD_LAYER_PATH", LAYER_TYPE_EXPLICIT); // LAYERS_PATHS_SDK this->paths[LAYERS_PATHS_SDK].clear(); @@ -481,7 +517,7 @@ void LayerManager::UpdatePathEnabled(const LayersPathInfo &path_info) { } } -std::vector LayerManager::BuildLayerNameList() const { +std::vector LayerManager::GatherLayerNames() const { std::vector result; for (std::size_t i = 0, n = this->selected_layers.size(); i < n; ++i) { @@ -498,3 +534,19 @@ std::vector LayerManager::BuildLayerNameList() const { return result; } + +std::vector LayerManager::GatherLayers(const LayersPathInfo &path_info) const { + std::vector result; + + for (std::size_t i = 0, n = this->selected_layers.size(); i < n; ++i) { + const std::string &layer_path = path_info.path.AbsolutePath(); + const std::string ¤t_layer_path = this->selected_layers[i].manifest_path.AbsolutePath(); + if (current_layer_path.find(layer_path) == std::string::npos) { + continue; + } + + result.push_back(&this->selected_layers[i]); + } + + return result; +} diff --git a/vkconfig_core/layer_manager.h b/vkconfig_core/layer_manager.h index 60952176fa..99ccd9ac65 100644 --- a/vkconfig_core/layer_manager.h +++ b/vkconfig_core/layer_manager.h @@ -55,7 +55,8 @@ class LayerManager : public Serialize { void RemovePath(const LayersPathInfo& path_info); void UpdatePathEnabled(const LayersPathInfo& path_info); - std::vector BuildLayerNameList() const; + std::vector GatherLayerNames() const; + std::vector GatherLayers(const LayersPathInfo& path_info) const; std::vector selected_layers; std::array, LAYERS_PATHS_COUNT> paths; diff --git a/vkconfig_core/registry.cpp b/vkconfig_core/registry.cpp index 9cc430bcd8..8ddf5085b3 100644 --- a/vkconfig_core/registry.cpp +++ b/vkconfig_core/registry.cpp @@ -60,25 +60,24 @@ void AppendRegistryEntriesForLayers(QString loader_settings_file, QString layers /// On Windows the overide json file and settings file are not used unless the path to those /// files are stored in the registry. -void RemoveRegistryEntriesForLayers(QString loader_settings_file, QString layers_settings_file) { +void RemoveRegistryEntriesForLayers() { // Layer override json file HKEY key; HKEY userKey = IsUserAnAdmin() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; REGSAM access = KEY_WRITE; - LSTATUS err = RegCreateKeyEx(userKey, TEXT("SOFTWARE\\Khronos\\Vulkan\\LoaderSettings"), 0, NULL, REG_OPTION_NON_VOLATILE, - access, NULL, &key, NULL); + LSTATUS err = + RegCreateKeyEx(userKey, TEXT("SOFTWARE\\Khronos\\Vulkan"), 0, NULL, REG_OPTION_NON_VOLATILE, access, NULL, &key, NULL); if (err != ERROR_SUCCESS) return; - RegDeleteValueW(key, (LPCWSTR)loader_settings_file.utf16()); + err = RegDeleteTreeW(key, (LPCWSTR)QString("LoaderSettings").utf16()); RegCloseKey(key); // Layer settings file - err = RegCreateKeyEx(userKey, TEXT("SOFTWARE\\Khronos\\Vulkan\\Settings"), 0, NULL, REG_OPTION_NON_VOLATILE, access, NULL, &key, - NULL); + err = RegCreateKeyEx(userKey, TEXT("SOFTWARE\\Khronos\\Vulkan"), 0, NULL, REG_OPTION_NON_VOLATILE, access, NULL, &key, NULL); if (err != ERROR_SUCCESS) return; - RegDeleteValueW(key, (LPCWSTR)layers_settings_file.utf16()); + err = RegDeleteTreeW(key, (LPCWSTR)QString("Settings").utf16()); RegCloseKey(key); } diff --git a/vkconfig_core/registry.h b/vkconfig_core/registry.h index 1b7b2e81b6..2fd52d9740 100644 --- a/vkconfig_core/registry.h +++ b/vkconfig_core/registry.h @@ -31,7 +31,7 @@ void AppendRegistryEntriesForLayers(QString override_file, QString settings_file); -void RemoveRegistryEntriesForLayers(QString override_file, QString settings_file); +void RemoveRegistryEntriesForLayers(); std::vector LoadRegistrySystemLayers(const char* path); diff --git a/vkconfig_core/test/test_layer_manager.cpp b/vkconfig_core/test/test_layer_manager.cpp index 9551a12573..9a21f27d64 100644 --- a/vkconfig_core/test/test_layer_manager.cpp +++ b/vkconfig_core/test/test_layer_manager.cpp @@ -204,7 +204,7 @@ TEST(test_layer_manager, BuildLayerNameList) { LayerManager layer_manager; layer_manager.LoadLayersFromPath(":/layers"); - EXPECT_EQ(layer_manager.BuildLayerNameList().size(), 11); + EXPECT_EQ(layer_manager.GatherLayerNames().size(), 11); } TEST(test_layer_manager, avoid_duplicate) { diff --git a/vkconfig_core/type_layers_paths.cpp b/vkconfig_core/type_layers_paths.cpp index 80260dda9f..353ecd5c53 100644 --- a/vkconfig_core/type_layers_paths.cpp +++ b/vkconfig_core/type_layers_paths.cpp @@ -24,12 +24,14 @@ const char* GetLabel(LayersPaths Layers_paths_type) { static const char* TABLE[] = { - "System Implicit Layers", // LAYERS_PATHS_IMPLICIT - "System Explicit Layers", // LAYERS_PATHS_EXPLICIT - "$VK_LAYER_PATH Layers", // LAYERS_PATHS_ENV_SET - "$VK_ADD_LAYER_PATH Layers", // LAYERS_PATHS_ENV_ADD - "Vulkan Configurator Layers", // LAYERS_PATHS_GUI - "$VULKAN_SDK Layers", // LAYERS_PATHS_SDK + "System Implicit Layers", // LAYERS_PATHS_IMPLICIT_SYSTEM + "${VK_IMPLICIT_LAYER_PATH} Layers", // LAYERS_PATHS_IMPLICIT_ENV_SET + "${VK_ADD_IMPLICIT_LAYER_PATH} Layers", // LAYERS_PATHS_IMPLICIT_ENV_ADD + "System Explicit Layers", // LAYERS_PATHS_EXPLICIT_SYSTEM + "${VK_LAYER_PATH} Layers", // LAYERS_PATHS_EXPLICIT_ENV_SET + "${VK_ADD_LAYER_PATH} Layers", // LAYERS_PATHS_EXPLICIT_ENV_ADD + "Vulkan Configurator Layers", // LAYERS_PATHS_GUI + "${VULKAN_SDK} Layers", // LAYERS_PATHS_SDK }; static_assert(std::size(TABLE) == LAYERS_PATHS_COUNT, "The tranlation table size doesn't match the enum number of elements"); diff --git a/vkconfig_core/type_layers_paths.h b/vkconfig_core/type_layers_paths.h index 42f575777c..08fbad002d 100644 --- a/vkconfig_core/type_layers_paths.h +++ b/vkconfig_core/type_layers_paths.h @@ -23,14 +23,16 @@ #include "type_layer_type.h" enum LayersPaths { - LAYERS_PATHS_IMPLICIT = 0, - LAYERS_PATHS_EXPLICIT, - LAYERS_PATHS_ENV_SET, // From $VK_LAYER_PATH - LAYERS_PATHS_ENV_ADD, // from $VK_ADD_LAYER_PATH + LAYERS_PATHS_IMPLICIT_SYSTEM = 0, + LAYERS_PATHS_IMPLICIT_ENV_SET, // From VK_IMPLICIT_LAYER_PATH + LAYERS_PATHS_IMPLICIT_ENV_ADD, // from VK_ADD_IMPLICIT_LAYER_PATH + LAYERS_PATHS_EXPLICIT_SYSTEM, + LAYERS_PATHS_EXPLICIT_ENV_SET, // From $VK_LAYER_PATH + LAYERS_PATHS_EXPLICIT_ENV_ADD, // from $VK_ADD_LAYER_PATH LAYERS_PATHS_GUI, LAYERS_PATHS_SDK, - LAYERS_PATHS_FIRST = LAYERS_PATHS_IMPLICIT, + LAYERS_PATHS_FIRST = LAYERS_PATHS_IMPLICIT_SYSTEM, LAYERS_PATHS_LAST = LAYERS_PATHS_SDK, }; diff --git a/vkconfig_core/util.cpp b/vkconfig_core/util.cpp index d8216921a7..f07c8f0b82 100644 --- a/vkconfig_core/util.cpp +++ b/vkconfig_core/util.cpp @@ -51,6 +51,13 @@ std::string format(const char* message, ...) { return buffer; } +std::string FormatNvidia(uint32_t driverVersion) { + return format("%d.%d.%d.%d", (driverVersion >> 22) & 0x3ff, (driverVersion >> 14) & 0x0ff, (driverVersion >> 6) & 0x0ff, + driverVersion & 0x003f); +} + +std::string FormatIntelWindows(uint32_t driverVersion) { return format("%d.%d", (driverVersion >> 14), (driverVersion)&0x3fff); } + bool IsFrames(const std::string& s) { static const std::regex FRAME_REGEX("^([0-9]+([-][0-9]+){0,2})(,([0-9]+([-][0-9]+){0,2}))*$"); diff --git a/vkconfig_core/util.h b/vkconfig_core/util.h index 2e9c5666d2..3607036331 100644 --- a/vkconfig_core/util.h +++ b/vkconfig_core/util.h @@ -37,6 +37,10 @@ std::string format(const char* message, ...); +std::string FormatNvidia(uint32_t driverVersion); + +std::string FormatIntelWindows(uint32_t driverVersion); + bool IsFrames(const std::string& s); bool IsNumber(const std::string& s); diff --git a/vkconfig_core/vulkan_info.cpp b/vkconfig_core/vulkan_info.cpp deleted file mode 100644 index 97f11feb64..0000000000 --- a/vkconfig_core/vulkan_info.cpp +++ /dev/null @@ -1,264 +0,0 @@ -/* - * Copyright (c) 2020-2024 Valve Corporation - * Copyright (c) 2020-2024 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Authors: - * - Christophe Riccio - */ - -#include "vulkan_info.h" -/* -static std::string GetUserDefinedLayersPathsLog(const char *label, UserDefinedLayersPaths custom_layer_path) { - std::string log; - - const std::vector &user_defined_layer_paths = - Configurator::Get().environment.GetUserDefinedLayersPaths(custom_layer_path); - if (!user_defined_layer_paths.empty()) { - log += format(" - %s:\n", label); - for (std::size_t i = 0, n = user_defined_layer_paths.size(); i < n; ++i) - log += format(" - %s\n", user_defined_layer_paths[i].AbsolutePath().c_str()); - } else - log += format(" - %s: None\n", label); - - return log; -} - -std::string GenerateVulkanStatus() { - std::string log; - - Configurator &configurator = Configurator::Get(); - - // Layers override configuration - switch (configurator.environment.GetMode()) { - default: - case LAYERS_CONTROLLED_BY_APPLICATIONS: - log += "- Vulkan Layers Controlled by Vulkan Applications\n"; - break; - case LAYERS_CONTROLLED_BY_CONFIGURATOR: - if (configurator.configurations.HasActiveConfiguration(configurator.layers.selected_layers)) { - log += format("- Vulkan Layers Controlled by \"%s\" configuration\n", - configurator.environment.GetSelectedConfiguration().c_str()); - } else { - log += format("- Vulkan Layers Controlled by Vulkan Configurator but no configuration selected\n", - configurator.environment.GetSelectedConfiguration().c_str()); - } - break; - case LAYERS_DISABLED_BY_CONFIGURATOR: - log += "- Vulkan Layers Disabled by Vulkan Configurator\n"; - break; - } - - log += "- Environment variables:\n"; - - // Check Vulkan SDK path - if (Get(Path::SDK).Empty()) - log += " - ${VULKAN_SDK} not set\n"; - else - log += format(" - ${VULKAN_SDK}: %s\n", AbsolutePath(Path::SDK).c_str()); - - // Check VK_HOME path - if (!Get(Path::HOME).Empty()) { - log += format(" - ${VK_HOME}: %s\n", AbsolutePath(Path::HOME).c_str()); - } - - const Version loader_version = GetVulkanLoaderVersion(); - - if (loader_version == Version::VERSION_NULL) { - Alert::LoaderFailure(); - - log += "- Could not find a Vulkan Loader.\n"; - return log; - } else { - log += format("- Vulkan Loader version: %s\n", loader_version.str().c_str()); - const LogFlags log_flags = configurator.environment.GetLoaderMessageFlags(); - if (log_flags != 0) { - log += format(" - ${VK_LOADER_DEBUG}=%s\n", GetLogString(log_flags).c_str()); - } - } - - log += "- User-Defined Layers locations:\n"; - log += GetUserDefinedLayersPathsLog("${VK_LAYER_PATH} variable", USER_DEFINED_LAYERS_PATHS_ENV_SET); - log += GetUserDefinedLayersPathsLog("Per-configuration paths", USER_DEFINED_LAYERS_PATHS_GUI); - log += GetUserDefinedLayersPathsLog("${VK_ADD_LAYER_PATH} variable", USER_DEFINED_LAYERS_PATHS_ENV_ADD); - - // vk_layer_settings.txt - const Path layer_settings_path(qgetenv("VK_LAYER_SETTINGS_PATH").toStdString()); - if (!layer_settings_path.Empty()) { - log += "- `vk_layer_settings.txt` location overridden by VK_LAYER_SETTINGS_PATH:\n"; - if (layer_settings_path.RelativePath().find("vk_layer_settings.txt") == std::string::npos) { - log += format(" %s\n", layer_settings_path.RelativePath().c_str()); - } else { - log += format(" %s\n", layer_settings_path.AbsoluteDir().c_str()); - } - } else { - log += "- `vk_layer_settings.txt` uses the default platform path:\n"; - log += format(" %s\n", AbsolutePath(Path::LAYERS_SETTINGS).c_str()); - } - - // vk_loader_settings.json - log += "- `vk_loader_settings.json` uses the default platform path:\n"; - log += format(" %s\n", AbsolutePath(Path::LOADER_SETTINGS).c_str()); - - // If there is no Vulkan loader installed, we can't call any Vulkan API. - if (loader_version == Version::VERSION_NULL) { - return log; - } - - LayersMode saved_mode = configurator.environment.GetMode(); - configurator.environment.SetMode(LAYERS_CONTROLLED_BY_APPLICATIONS); - configurator.Configure(configurator.layers.selected_layers); - - QLibrary library(GetVulkanLibrary()); - PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = - (PFN_vkEnumerateInstanceLayerProperties)library.resolve("vkEnumerateInstanceLayerProperties"); - assert(vkEnumerateInstanceLayerProperties); - - std::uint32_t instance_layer_count = 0; - VkResult err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL); - assert(!err); - - std::vector layers_properties; - layers_properties.resize(instance_layer_count); - - err = vkEnumerateInstanceLayerProperties(&instance_layer_count, &layers_properties[0]); - assert(!err); - - log += "- Available Layers:\n"; - for (std::size_t i = 0, n = layers_properties.size(); i < n; ++i) { - const Layer *layer = FindByKey(configurator.layers.selected_layers, layers_properties[i].layerName); - - std::string status; - if (layer != nullptr) { - if (layer->status != STATUS_STABLE) { - status = GetToken(layer->status); - } - } - - if (status.empty()) { - log += format(" - %s\n", layers_properties[i].layerName); - } else { - log += format(" - %s (%s)\n", layers_properties[i].layerName, status.c_str()); - } - } - - VkInstance inst = VK_NULL_HANDLE; - err = CreateInstance(library, inst, false); - if (err == VK_ERROR_INCOMPATIBLE_DRIVER) { - // If no compatible driver were found, trying with portability enumeration - err = CreateInstance(library, inst, true); - if (err == VK_ERROR_INCOMPATIBLE_DRIVER) { - Alert::InstanceFailure(); - - log += "- Cannot find a compatible Vulkan installable client driver (ICD).\n"; - return log; - } - } - assert(err == VK_SUCCESS); - - PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = - (PFN_vkEnumeratePhysicalDevices)library.resolve("vkEnumeratePhysicalDevices"); - assert(vkEnumeratePhysicalDevices); - - PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = - (PFN_vkEnumerateInstanceExtensionProperties)library.resolve("vkEnumerateInstanceExtensionProperties"); - assert(vkEnumerateInstanceExtensionProperties); - - VkResult result = VK_SUCCESS; - - uint32_t instance_extension_count = 0; - result = vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, nullptr); - - std::vector instance_extensions; - if (instance_extension_count > 0) { - instance_extensions.resize(instance_extension_count); - } - result = vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, instance_extensions.data()); - - bool has_device_id = false; - if (result == VK_SUCCESS) { - for (std::size_t i = 0, n = instance_extensions.size(); i < n; ++i) { - if (instance_extensions[i].extensionName == std::string(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) { - has_device_id = true; - break; - } - } - } - - uint32_t gpu_count = 0; - err = vkEnumeratePhysicalDevices(inst, &gpu_count, NULL); - - PFN_vkDestroyInstance vkDestroyInstance = (PFN_vkDestroyInstance)library.resolve("vkDestroyInstance"); - assert(vkDestroyInstance); - - // This can fail on a new Linux setup. Check and fail gracefully rather than crash. - if (err != VK_SUCCESS) { - Alert::PhysicalDeviceFailure(); - vkDestroyInstance(inst, NULL); - - log += "- Cannot find a compatible Vulkan installable client driver (ICD).\n"; - return log; - } - - std::vector devices; - devices.resize(gpu_count); - - err = vkEnumeratePhysicalDevices(inst, &gpu_count, &devices[0]); - assert(!err); - - PFN_vkGetPhysicalDeviceProperties pfnGetPhysicalDeviceProperties = - (PFN_vkGetPhysicalDeviceProperties)library.resolve("vkGetPhysicalDeviceProperties"); - assert(pfnGetPhysicalDeviceProperties); - - Configurator &configurator_edit = Configurator::Get(); - configurator_edit.device_names.clear(); - - log += "- Physical Devices:\n"; - for (std::size_t i = 0, n = devices.size(); i < n; ++i) { - VkPhysicalDeviceProperties properties; - pfnGetPhysicalDeviceProperties(devices[i], &properties); - - const std::string vk_version = format("%d.%d.%d", VK_VERSION_MAJOR(properties.apiVersion), - VK_VERSION_MINOR(properties.apiVersion), VK_VERSION_PATCH(properties.apiVersion)); - - log += format(" - %s with Vulkan %s\n", properties.deviceName, vk_version.c_str()); - - if (has_device_id) { - PFN_vkGetPhysicalDeviceProperties2 pfnGetPhysicalDeviceProperties2 = - (PFN_vkGetPhysicalDeviceProperties2)library.resolve("vkGetPhysicalDeviceProperties2"); - assert(pfnGetPhysicalDeviceProperties2); - - VkPhysicalDeviceIDPropertiesKHR properties_deviceid{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, nullptr}; - VkPhysicalDeviceProperties2 properties2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &properties_deviceid}; - - pfnGetPhysicalDeviceProperties2(devices[i], &properties2); - - const std::string deviceUUID = GetUUIDString(properties_deviceid.deviceUUID); - log += format(" - deviceUUID: %s\n", deviceUUID.c_str()); - - const std::string driverUUID = GetUUIDString(properties_deviceid.driverUUID); - log += format(" - driverUUID: %s\n", driverUUID.c_str()); - } - - configurator_edit.device_names.push_back(properties.deviceName); - } - - vkDestroyInstance(inst, NULL); - - configurator.environment.SetMode(saved_mode); - configurator.Configure(configurator.layers.selected_layers); - - return log; -} -*/ diff --git a/vkconfig_core/vulkan_info.h b/vkconfig_core/vulkan_info.h deleted file mode 100644 index 0a9890b56e..0000000000 --- a/vkconfig_core/vulkan_info.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2020-2024 Valve Corporation - * Copyright (c) 2020-2024 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Authors: - * - Christophe Riccio - */ - -#pragma once - -#include "version.h" - -#include - -#include - -struct VulkanPhysicalDeviceInfo { - std::string deviceName; - std::string deviceUUID; - std::string driverUUID; - Version apiVersion; -}; - -struct VulkanSystemInfo { - Version loaderVersion = Version::NONE; - std::vector instanceLayerProperties; - std::vector instanceExtensionPropertie; - std::vector physicalDevices; -}; diff --git a/vkconfig_core/vulkan_util.cpp b/vkconfig_core/vulkan_util.cpp index 3d4f32bd8b..4815b3ddc0 100644 --- a/vkconfig_core/vulkan_util.cpp +++ b/vkconfig_core/vulkan_util.cpp @@ -42,6 +42,16 @@ static std::string GetUUIDString(const uint8_t deviceUUID[VK_UUID_SIZE]) { return result; } +static std::string GetLUIDString(const uint8_t deviceLUID[VK_LUID_SIZE]) { + std::string result; + + for (std::size_t i = 0, n = VK_LUID_SIZE; i < n; ++i) { + result += format("%02X", deviceLUID[i]); + } + + return result; +} + struct VulkanFunctions { VulkanFunctions(); bool Validate() const; @@ -183,8 +193,13 @@ VulkanSystemInfo BuildVulkanSystemInfo() { device_info.deviceName = properties2.properties.deviceName; device_info.apiVersion = Version(properties2.properties.apiVersion); + device_info.driverVersion = properties2.properties.driverVersion; + device_info.vendorID = static_cast(properties2.properties.vendorID); + device_info.deviceID = properties2.properties.deviceID; + device_info.deviceType = properties2.properties.deviceType; device_info.deviceUUID = GetUUIDString(properties_deviceid.deviceUUID); device_info.driverUUID = GetUUIDString(properties_deviceid.driverUUID); + device_info.deviceLUID = GetLUIDString(properties_deviceid.deviceLUID); } vk.DestroyInstance(instance, NULL); @@ -287,3 +302,42 @@ std::vector BuildEnvVariablesList(const char *layer_key, const char return results; } + +const char *GetLabel(VkPhysicalDeviceType deviceType) { + static const char *TABLES[] = { + "", // VK_PHYSICAL_DEVICE_TYPE_OTHER + "Integrated", // VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU + "Discrete", // VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU + "Virtual", // VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU + "CPU" // VK_PHYSICAL_DEVICE_TYPE_CPU + }; + + return TABLES[deviceType]; +} + +std::string GetLabel(VendorID vendorID) { + switch (vendorID) { + default: + return "Unknown Vendor"; + case VK_VENDOR_ID_KHRONOS: + return "KHRONOS"; + case VK_VENDOR_ID_MESA: + return "Mesa"; + case VENDOR_ID_AMD: + return "AMD"; + case VENDOR_ID_APPLE: + return "Apple"; + case VENDOR_ID_ARM: + return "ARM"; + case VENDOR_ID_IMGTEC: + return "Imagination"; + case VENDOR_ID_INTEL: + return "Intel"; + case VENDOR_ID_MICROSOFT: + return "Microsoft"; + case VENDOR_ID_NVIDIA: + return "Nvidia"; + case VENDOR_ID_QUALCOMM: + return "Qualcomm"; + } +} diff --git a/vkconfig_core/vulkan_util.h b/vkconfig_core/vulkan_util.h index c8a0cb97f6..652308cc5a 100644 --- a/vkconfig_core/vulkan_util.h +++ b/vkconfig_core/vulkan_util.h @@ -20,12 +20,51 @@ #pragma once -#include "../vkconfig_core/vulkan_info.h" +#include "version.h" + +#include + #include #include extern const Version REQUIRED_LOADER_VERSION; +enum VendorID { + VENDOR_ID_KHRONOS = VK_VENDOR_ID_KHRONOS, + VENDOR_ID_MESA = VK_VENDOR_ID_MESA, + VENDOR_ID_AMD = 0x1022, + VENDOR_ID_APPLE = 0x106B, + VENDOR_ID_ARM = 0x13B5, + VENDOR_ID_IMGTEC = 0x1010, + VENDOR_ID_INTEL = 0x8086, + VENDOR_ID_MICROSOFT = 0x1414, + VENDOR_ID_NVIDIA = 0x10DE, + VENDOR_ID_QUALCOMM = 0x17CB, +}; + +struct VulkanPhysicalDeviceInfo { + std::string deviceName; + std::string deviceUUID; + std::string driverUUID; + std::string deviceLUID; + Version apiVersion; + uint32_t driverVersion; + VendorID vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; +}; + +struct VulkanSystemInfo { + Version loaderVersion = Version::NONE; + std::vector instanceLayerProperties; + std::vector instanceExtensionPropertie; + std::vector physicalDevices; +}; + VulkanSystemInfo BuildVulkanSystemInfo(); std::vector BuildEnvVariablesList(const char *layer_key, const char *setting_key); + +const char *GetLabel(VkPhysicalDeviceType deviceType); + +std::string GetLabel(VendorID vendorID); diff --git a/vkconfig_gui/main.cpp b/vkconfig_gui/main.cpp index 922ebf222c..2800bb3dd6 100644 --- a/vkconfig_gui/main.cpp +++ b/vkconfig_gui/main.cpp @@ -58,19 +58,19 @@ int main(int argc, char* argv[]) { Configurator& configurator = Configurator::Get(); configurator.Surrender(OVERRIDE_AREA_LOADER_SETTINGS_BIT); - const VulkanSystemInfo& vulkan_info = BuildVulkanSystemInfo(); + configurator.vulkan_system_info = BuildVulkanSystemInfo(); - if (vulkan_info.loaderVersion == Version::NONE) { + if (configurator.vulkan_system_info.loaderVersion == Version::NONE) { Alert::StartLoaderFailure(); return -1; } - if (vulkan_info.loaderVersion < REQUIRED_LOADER_VERSION) { - Alert::StartLoaderIncompatibleVersions(vulkan_info.loaderVersion, REQUIRED_LOADER_VERSION); + if (configurator.vulkan_system_info.loaderVersion < REQUIRED_LOADER_VERSION) { + Alert::StartLoaderIncompatibleVersions(configurator.vulkan_system_info.loaderVersion, REQUIRED_LOADER_VERSION); return -1; } - if (vulkan_info.physicalDevices.empty()) { + if (configurator.vulkan_system_info.physicalDevices.empty()) { Alert::StartPhysicalDeviceFailure(); return -1; } diff --git a/vkconfig_gui/mainwindow.ui b/vkconfig_gui/mainwindow.ui index 195e4af38f..7c59ebaca1 100644 --- a/vkconfig_gui/mainwindow.ui +++ b/vkconfig_gui/mainwindow.ui @@ -83,7 +83,7 @@ QTabWidget::Rounded - 4 + 3 @@ -1477,6 +1477,9 @@ + + ${VK_HOME} is the default environment variable for Vulkan SDK tools outputs implementing it. + ${VK_HOME}: @@ -1499,9 +1502,20 @@ + + + Consolas + 10 + 50 + false + + Qt::ScrollBarAlwaysOn + + true + diff --git a/vkconfig_gui/tab_diagnostics.cpp b/vkconfig_gui/tab_diagnostics.cpp index 8361a1172b..dd5cc7a162 100644 --- a/vkconfig_gui/tab_diagnostics.cpp +++ b/vkconfig_gui/tab_diagnostics.cpp @@ -50,7 +50,7 @@ TabDiagnostics::~TabDiagnostics() {} void TabDiagnostics::UpdateUI(UpdateUIMode mode) { Configurator &configurator = Configurator::Get(); - this->ui->diagnostic_status_text->setMarkdown(configurator.GenerateVulkanStatus().c_str()); + this->ui->diagnostic_status_text->setText(configurator.GenerateVulkanStatus().c_str()); } void TabDiagnostics::CleanUI() {} diff --git a/vkconfig_gui/vkconfig.pro b/vkconfig_gui/vkconfig.pro index 4bf29fc93b..0021c6b3ed 100644 --- a/vkconfig_gui/vkconfig.pro +++ b/vkconfig_gui/vkconfig.pro @@ -73,7 +73,6 @@ SOURCES += \ ../vkconfig_core/util.cpp \ ../vkconfig_core/ui.cpp \ ../vkconfig_core/version.cpp \ - ../vkconfig_core/vulkan_info.cpp \ ../vkconfig_core/vulkan_util.cpp \ widget_resize_button.cpp \ widget_layer_version.cpp \ @@ -151,7 +150,6 @@ HEADERS += \ ../vkconfig_core/util.h \ ../vkconfig_core/ui.h \ ../vkconfig_core/version.h \ - ../vkconfig_core/vulkan_info.h \ ../vkconfig_core/vulkan_util.h \ widget_resize_button.h \ widget_layer_version.h \