vkconfig: Improve layers tab

Change-Id: Ie81261c89228ad4ba89b71da3207b255eefd9e72

Author: christophe-lunarg

vkconfig_core/layer.cpp

@@ -49,11 +49,9 @@
 #include <string>
 #include <algorithm>
 
-bool operator<(const LayersPathInfo& a, const LayersPathInfo& b) { return a.path.RelativePath() < b.path.RelativePath(); }
-
-bool Found(const std::vector<LayersPathInfo>& data, const Path& path) {
+bool Found(const std::vector<Path>& data, const Path& path) {
     for (std::size_t i = 0, n = data.size(); i < n; ++i) {
-        if (data[i].path == path) {
+        if (data[i] == path) {
             return true;
         }
     }
@@ -407,6 +405,14 @@ LayerLoadStatus Layer::Load(const Path& full_path_to_file, LayerType type, bool
     return this->IsValid() ? LAYER_LOAD_ADDED : LAYER_LOAD_INVALID;  // Not all JSON file are layer JSON valid
 }
 
+bool operator<(const Layer& layer_a, const Layer& layer_b) {
+    if (layer_a.key == layer_b.key) {
+        return layer_a.api_version < layer_b.api_version;
+    } else {
+        return layer_a.key < layer_b.key;
+    }
+}
+
 void CollectDefaultSettingData(const SettingMetaSet& meta_set, SettingDataSet& data_set) {
     for (std::size_t i = 0, n = meta_set.size(); i < n; ++i) {
         SettingMeta* setting_meta = meta_set[i];

vkconfig_core/layer.h

@@ -37,20 +37,13 @@
 #include <string>
 
 struct LayerStatus {
+    LayerType type = LAYER_TYPE_EXPLICIT;
     std::string last_modified;
     bool validated = false;
-    bool disabled = false;
-};
-
-struct LayersPathInfo {
-    Path path;
-    LayerType type = LAYER_TYPE_EXPLICIT;
     bool enabled = true;
 };
 
-bool operator<(const LayersPathInfo& a, const LayersPathInfo& b);
-
-bool Found(const std::vector<LayersPathInfo>& data, const Path& path);
+bool Found(const std::vector<Path>& data, const Path& path);
 
 enum LayerLoadStatus {
     LAYER_LOAD_ADDED = 0,
@@ -129,4 +122,6 @@ class Layer {
     std::vector<std::shared_ptr<SettingMeta> > memory;  // Settings are deleted when all layers instances are deleted.
 };
 
+bool operator<(const Layer& layer_a, const Layer& layer_b);
+
 void CollectDefaultSettingData(const SettingMetaSet& meta_set, SettingDataSet& data_set);

vkconfig_core/layer_manager.cpp

@@ -25,36 +25,34 @@
 
 #include <QJsonArray>
 
-std::vector<LayersPathInfo> GetEnvVariablePaths(const char *variable_name, LayerType type) {
-    std::vector<LayersPathInfo> result;
+static std::vector<Path> GetEnvVariablePaths(const char *variable_name, LayerType type) {
+    std::vector<Path> result;
 
     const char *SEPARATOR = GetToken(PARSE_ENV_VAR);
 
     const std::vector<std::string> &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;
+        result[i] = paths[i];
     }
 
     return result;
 }
 
-std::vector<LayersPathInfo> GetImplicitLayerPaths() {
-    std::vector<LayersPathInfo> result;
+static std::vector<Path> GetImplicitLayerPaths() {
+    std::vector<Path> result;
 
 #if VKC_ENV == VKC_ENV_WIN32
-    const std::vector<LayersPathInfo> &admin_registry_paths =
+    const std::vector<Path> &admin_registry_paths =
         LoadRegistrySoftwareLayers("HKEY_LOCAL_MACHINE\\Software\\Khronos\\Vulkan\\ImplicitLayers", LAYER_TYPE_IMPLICIT);
     result.insert(result.begin(), admin_registry_paths.begin(), admin_registry_paths.end());
 
-    const std::vector<LayersPathInfo> &user_registry_paths =
+    const std::vector<Path> &user_registry_paths =
         LoadRegistrySoftwareLayers("HKEY_CURRENT_USER\\Software\\Khronos\\Vulkan\\ImplicitLayers", LAYER_TYPE_IMPLICIT);
     result.insert(result.begin(), user_registry_paths.begin(), user_registry_paths.end());
 
     // Search for drivers specific layers
-    const std::vector<LayersPathInfo> &drivers_registry_paths =
+    const std::vector<Path> &drivers_registry_paths =
         LoadRegistrySystemLayers("HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Class\\...\\VulkanImplicitLayers");
     result.insert(result.begin(), drivers_registry_paths.begin(), drivers_registry_paths.end());
 #else
@@ -101,20 +99,20 @@ std::vector<LayersPathInfo> GetImplicitLayerPaths() {
     return result;
 }
 
-std::vector<LayersPathInfo> GetExplicitLayerPaths() {
-    std::vector<LayersPathInfo> result;
+std::vector<Path> GetExplicitLayerPaths() {
+    std::vector<Path> result;
 
 #if VKC_ENV == VKC_ENV_WIN32
-    const std::vector<LayersPathInfo> &admin_registry_paths =
+    const std::vector<Path> &admin_registry_paths =
         LoadRegistrySoftwareLayers("HKEY_LOCAL_MACHINE\\Software\\Khronos\\Vulkan\\ExplicitLayers", LAYER_TYPE_EXPLICIT);
     result.insert(result.begin(), admin_registry_paths.begin(), admin_registry_paths.end());
 
-    const std::vector<LayersPathInfo> &user_registry_paths =
+    const std::vector<Path> &user_registry_paths =
         LoadRegistrySoftwareLayers("HKEY_CURRENT_USER\\Software\\Khronos\\Vulkan\\ExplicitLayers", LAYER_TYPE_EXPLICIT);
     result.insert(result.begin(), user_registry_paths.begin(), user_registry_paths.end());
 
     // Search for drivers specific layers
-    const std::vector<LayersPathInfo> &drivers_registry_paths =
+    const std::vector<Path> &drivers_registry_paths =
         LoadRegistrySystemLayers("HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Class\\...\\VulkanExplicitLayers");
     result.insert(result.begin(), drivers_registry_paths.begin(), drivers_registry_paths.end());
 #else
@@ -161,27 +159,18 @@ std::vector<LayersPathInfo> GetExplicitLayerPaths() {
     return result;
 }
 
-static LayersPathInfo *FindPathInfo(std::array<std::vector<LayersPathInfo>, LAYERS_PATHS_COUNT> &paths, const std::string &path) {
-    for (int paths_type_index = LAYERS_PATHS_FIRST; paths_type_index <= LAYERS_PATHS_LAST; ++paths_type_index) {
-        for (std::size_t i = 0, n = paths[paths_type_index].size(); i < n; ++i) {
-            if (paths[paths_type_index][i].path == path) {
-                return &paths[paths_type_index][i];
-            }
-        }
-    }
-
-    return nullptr;
-}
-
-LayerManager::LayerManager() { this->InitSystemPaths(); }
+LayerManager::LayerManager() {}
 
 bool LayerManager::Load(const QJsonObject &json_root_object, ConfiguratorMode configurator_mode) {
+    this->available_layers.clear();
+    this->layers_found.clear();
+
     // LAYERS_PATHS_GUI
     if (json_root_object.value("layers") != QJsonValue::Undefined) {
         const QJsonObject &json_layers_object = json_root_object.value("layers").toObject();
 
-        if (json_layers_object.value("last_layers_path") != QJsonValue::Undefined) {
-            this->last_layers_path = json_layers_object.value("last_layers_path").toString().toStdString();
+        if (json_layers_object.value("last_layers_dir") != QJsonValue::Undefined) {
+            this->last_layers_dir = json_layers_object.value("last_layers_dir").toString().toStdString();
         }
 
         if (json_layers_object.value("validate_manifests") != QJsonValue::Undefined) {
@@ -196,27 +185,20 @@ bool LayerManager::Load(const QJsonObject &json_root_object, ConfiguratorMode co
                 const QJsonObject &json_status_object = json_layers_found_object.value(json_layers_found_keys[i]).toObject();
 
                 LayerStatus layer_status;
+                if (json_status_object.value("type") != QJsonValue::Undefined) {
+                    layer_status.type = ::GetLayerType(json_status_object.value("type").toString().toStdString().c_str());
+                }
                 layer_status.last_modified = json_status_object.value("last_modified").toString().toStdString();
                 layer_status.validated = json_status_object.value("validated").toBool();
-                layer_status.disabled = json_status_object.value("disabled").toBool();
+                if (json_status_object.value("enabled") != QJsonValue::Undefined) {
+                    layer_status.enabled = json_status_object.value("enabled").toBool();
+                }
 
                 const Path &manifest_path = json_layers_found_keys[i].toStdString();
 
                 this->layers_found.insert(std::make_pair(manifest_path, layer_status));
             }
         }
-
-        if (json_layers_object.value("paths") != QJsonValue::Undefined) {
-            const QJsonObject &json_paths_object = json_layers_object.value("paths").toObject();
-            const QStringList &json_paths_keys = json_paths_object.keys();
-
-            for (int i = 0, n = json_paths_keys.length(); i < n; ++i) {
-                LayersPathInfo info;
-                info.path = json_paths_keys[i].toStdString();
-                info.enabled = json_paths_object.value(json_paths_keys[i].toStdString().c_str()).toBool();
-                this->AppendPath(info);
-            }
-        }
     }
 
     this->LoadAllInstalledLayers(configurator_mode);
@@ -229,25 +211,16 @@ bool LayerManager::Save(QJsonObject &json_root_object) const {
     for (auto it = this->layers_found.begin(); it != this->layers_found.end(); ++it) {
         QJsonObject json_layer_status_object;
         json_layer_status_object.insert("last_modified", it->second.last_modified.c_str());
+        json_layer_status_object.insert("type", ::GetToken(it->second.type));
         json_layer_status_object.insert("validated", it->second.validated);
-        json_layer_status_object.insert("disabled", it->second.disabled);
+        json_layer_status_object.insert("enabled", it->second.enabled);
         json_layers_status_object.insert(it->first.AbsolutePath().c_str(), json_layer_status_object);
     }
 
-    QJsonObject json_paths_object;
-    for (int paths_type_index = LAYERS_PATHS_FIRST; paths_type_index <= LAYERS_PATHS_LAST; ++paths_type_index) {
-        const std::vector<LayersPathInfo> &path_infos = this->paths[paths_type_index];
-
-        for (std::size_t i = 0, n = path_infos.size(); i < n; ++i) {
-            json_paths_object.insert(path_infos[i].path.RelativePath().c_str(), path_infos[i].enabled);
-        }
-    }
-
     QJsonObject json_layers_object;
     json_layers_object.insert("validate_manifests", this->validate_manifests);
-    json_layers_object.insert("last_layers_path", this->last_layers_path.RelativePath().c_str());
+    json_layers_object.insert("last_layers_dir", this->last_layers_dir.RelativePath().c_str());
     json_layers_object.insert("found", json_layers_status_object);
-    json_layers_object.insert("paths", json_paths_object);
 
     json_root_object.insert("layers", json_layers_object);
 
@@ -308,7 +281,7 @@ std::string LayerManager::Log() const {
 
     return log;
 }
-
+/*
 void LayerManager::InitSystemPaths() {
     this->available_layers.clear();
     this->layers_found.clear();
@@ -342,7 +315,7 @@ void LayerManager::InitSystemPaths() {
         this->paths[LAYERS_PATHS_SDK].push_back(info);
     }
 }
-
+*/
 void LayerManager::Clear() { this->available_layers.clear(); }
 
 bool LayerManager::Empty() const { return this->available_layers.empty(); }
@@ -471,24 +444,41 @@ Layer *LayerManager::FindFromManifest(const Path &manifest_path, bool find_disab
 
 // Find all installed layers on the system.
 void LayerManager::LoadAllInstalledLayers(ConfiguratorMode configurator_mode) {
-    this->available_layers.clear();
+    std::array<std::vector<Path>, LAYERS_PATHS_COUNT> paths;
 
-    for (std::size_t group_index = 0, group_count = this->paths.size(); group_index < group_count; ++group_index) {
+    // Search new layers
+    paths[LAYERS_PATHS_IMPLICIT_SYSTEM] = GetImplicitLayerPaths();
+
+    // LAYERS_PATHS_IMPLICIT_ENV_SET: VK_IMPLICIT_LAYER_PATH env variables
+    paths[LAYERS_PATHS_IMPLICIT_ENV_SET] = GetEnvVariablePaths("VK_IMPLICIT_LAYER_PATH", LAYER_TYPE_IMPLICIT);
+
+    // LAYERS_PATHS_IMPLICIT_ENV_ADD: VK_ADD_IMPLICIT_LAYER_PATH env variables
+    paths[LAYERS_PATHS_IMPLICIT_ENV_ADD] = GetEnvVariablePaths("VK_ADD_IMPLICIT_LAYER_PATH", LAYER_TYPE_IMPLICIT);
+
+    // LAYERS_PATHS_EXPLICIT_SYSTEM
+    paths[LAYERS_PATHS_EXPLICIT_SYSTEM] = GetExplicitLayerPaths();
+
+    // LAYERS_PATHS_EXPLICIT_ENV_SET: VK_LAYER_PATH env variables
+    paths[LAYERS_PATHS_EXPLICIT_ENV_SET] = GetEnvVariablePaths("VK_LAYER_PATH", LAYER_TYPE_EXPLICIT);
+
+    // LAYERS_PATHS_EXPLICIT_ENV_ADD: VK_ADD_LAYER_PATH env variables
+    paths[LAYERS_PATHS_EXPLICIT_ENV_ADD] = GetEnvVariablePaths("VK_ADD_LAYER_PATH", LAYER_TYPE_EXPLICIT);
+
+    // LAYERS_PATHS_SDK
+    paths[LAYERS_PATHS_SDK].clear();
+    paths[LAYERS_PATHS_SDK].push_back(Path(Path::SDK_EXPLICIT_LAYERS));
+
+    for (std::size_t group_index = 0, group_count = paths.size(); group_index < group_count; ++group_index) {
         const LayersPaths layers_path = static_cast<LayersPaths>(group_index);
 
-        const std::vector<LayersPathInfo> &paths_group = this->paths[group_index];
+        const std::vector<Path> &paths_group = paths[group_index];
         for (std::size_t i = 0, n = paths_group.size(); i < n; ++i) {
-            this->LoadLayersFromPath(paths_group[i].path, paths_group[i].type, configurator_mode);
-            this->UpdatePathEnabled(paths_group[i], layers_path);
-        }
-    }
-}
-
-void LayerManager::LoadLayersFromPath(const Path &layers_path, LayerType type, ConfiguratorMode configurator_mode) {
-    const std::vector<Path> &layers_paths = CollectFilePaths(layers_path);
+            const std::vector<Path> &layers_paths = CollectFilePaths(paths_group[i]);
 
-    for (std::size_t i = 0, n = layers_paths.size(); i < n; ++i) {
-        this->LoadLayer(layers_paths[i], type, configurator_mode);
+            for (std::size_t j = 0, o = layers_paths.size(); j < o; ++j) {
+                this->LoadLayer(layers_paths[j], ::GetLayerType(layers_path), configurator_mode);
+            }
+        }
     }
 }
 
@@ -600,21 +590,6 @@ void LayerManager::UpdatePathEnabled(const LayersPathInfo &path_info, LayersPath
     this->UpdateLayersEnabled(path_info);
 }
 
-void LayerManager::UpdateLayersEnabled(const LayersPathInfo &path_info) {
-    const bool are_enabled = this->AreLayersEnabled(path_info);
-
-    const std::vector<Path> &layers_paths = ::CollectFilePaths(path_info.path);
-
-    for (std::size_t i = 0, n = layers_paths.size(); i < n; ++i) {
-        Layer *layer = this->FindFromManifest(layers_paths[i], true);
-        if (layer == nullptr) {
-            continue;
-        }
-
-        layer->enabled = are_enabled;
-    }
-}
-
 std::vector<Path> LayerManager::CollectManifestPaths() const {
     std::vector<Path> results;
 
@@ -645,8 +620,8 @@ std::vector<std::string> LayerManager::GatherLayerNames() const {
 
     return result;
 }
-
-std::vector<const Layer *> LayerManager::GatherLayers(const LayersPathInfo &path_info) const {
+/*
+std::vector<const Layer *> LayerManager::GatherLayers(const Path& path) const {
     std::vector<const Layer *> result;
 
     for (std::size_t i = 0, n = this->available_layers.size(); i < n; ++i) {
@@ -661,3 +636,4 @@ std::vector<const Layer *> LayerManager::GatherLayers(const LayersPathInfo &path
 
     return result;
 }
+*/

vkconfig_core/layer_manager.h

@@ -49,26 +49,24 @@ class LayerManager : public Serialize {
     Layer* FindFromManifest(const Path& manifest_path, bool find_disabled_layers = false);
 
     void LoadAllInstalledLayers(ConfiguratorMode configurator_mode);
-    void LoadLayersFromPath(const Path& layers_path, LayerType type, ConfiguratorMode configurator_mode);
     LayerLoadStatus LoadLayer(const Path& layer_path, LayerType type, ConfiguratorMode configurator_mode);
 
-    bool AreLayersEnabled(const LayersPathInfo& path_info) const;
-    void AppendPath(const LayersPathInfo& path_info);
-    void RemovePath(const LayersPathInfo& path_info);
-    void UpdatePathEnabled(const LayersPathInfo& path_info, LayersPaths layers_paths);
+    /*
+        bool AreLayersEnabled(const LayersPathInfo& path_info) const;
+        void AppendPath(const LayersPathInfo& path_info);
+        void RemovePath(const LayersPathInfo& path_info);
+        void UpdatePathEnabled(const LayersPathInfo& path_info, LayersPaths layers_paths);
+    */
     std::vector<Path> CollectManifestPaths() const;
 
     std::vector<std::string> GatherLayerNames() const;
-    std::vector<const Layer*> GatherLayers(const LayersPathInfo& path_info) const;
+    //    std::vector<const Layer*> GatherLayers(const Path& path) const;
 
     std::vector<Layer> available_layers;
-    std::array<std::vector<LayersPathInfo>, LAYERS_PATHS_COUNT> paths;
-    Path last_layers_path = Path(Path::HOME);
+    // std::array<std::vector<LayersPathInfo>, LAYERS_PATHS_COUNT> paths;
+    Path last_layers_dir = Path(Path::HOME);
     bool validate_manifests = false;
 
    private:
-    void InitSystemPaths();
-    void UpdateLayersEnabled(const LayersPathInfo& path_info);
-
     std::map<Path, LayerStatus> layers_found;
 };