vkconfig3: Support multiple layers of the same api version

vkconfig_core/configuration.cpp

@@ -440,15 +440,28 @@ bool Configuration::HasMissingLayer(const LayerManager& layers, std::vector<std:
     return !missing_layers.empty();
 }
 
-void Configuration::SwitchLayerVersion(const LayerManager& layers, const std::string& layer_key, const Version& version) {
+void Configuration::SwitchLayerVersion(const LayerManager& layers, const std::string& layer_key, const Path& manifest_path) {
+    assert(!manifest_path.Empty());
+
+    Parameter* parameter = this->Find(layer_key);
+    assert(parameter != nullptr);
+
+    const Layer* new_layer = layers.FindFromManifest(manifest_path);
+
+    parameter->api_version = new_layer->api_version;
+    parameter->manifest = new_layer->manifest_path;
+    ::CollectDefaultSettingData(new_layer->settings, parameter->settings);
+}
+
+void Configuration::SwitchLayerLatest(const LayerManager& layers, const std::string& layer_key) {
     Parameter* parameter = this->Find(layer_key);
     assert(parameter != nullptr);
 
-    const Layer* new_layer = layers.Find(layer_key, version);
+    const Layer* new_layer = layers.Find(layer_key, Version::LATEST);
 
-    parameter->api_version = new_layer->api_version == version ? version : Version::LATEST;
+    parameter->api_version = Version::LATEST;
     parameter->manifest = new_layer->manifest_path;
-    CollectDefaultSettingData(new_layer->settings, parameter->settings);
+    ::CollectDefaultSettingData(new_layer->settings, parameter->settings);
 }
 
 void Configuration::GatherParameters(const LayerManager& layers) {

vkconfig_core/configuration.h

@@ -48,7 +48,8 @@ class Configuration {
     const Parameter* GetActiveParameter() const;
 
     bool HasMissingLayer(const LayerManager& layers, std::vector<std::string>& missing_layers) const;
-    void SwitchLayerVersion(const LayerManager& layers, const std::string& layer_key, const Version& version);
+    void SwitchLayerVersion(const LayerManager& layers, const std::string& layer_key, const Path& manifest_path);
+    void SwitchLayerLatest(const LayerManager& layers, const std::string& layer_key);
     void GatherParameters(const LayerManager& layers);
     void Reorder(const std::vector<std::string>& layer_names);
 

vkconfig_core/layer_manager.cpp

@@ -247,6 +247,24 @@ bool LayerManager::Empty() const { return this->selected_layers.empty(); }
 
 std::size_t LayerManager::Size() const { return this->selected_layers.size(); }
 
+std::vector<Path> LayerManager::GatherManifests(const std::string &layer_name) const {
+    std::vector<Path> result;
+
+    for (std::size_t i = 0, n = this->selected_layers.size(); i < n; ++i) {
+        if (!this->selected_layers[i].enabled) {
+            continue;
+        }
+
+        if (this->selected_layers[i].key == layer_name) {
+            result.push_back(this->selected_layers[i].manifest_path);
+        }
+    }
+
+    std::sort(result.rbegin(), result.rend());
+
+    return result;
+}
+
 std::vector<Version> LayerManager::GatherVersions(const std::string &layer_name) const {
     std::vector<Version> result;
 
@@ -285,25 +303,42 @@ const Layer *LayerManager::Find(const std::string &layer_name, const Version &la
 
         return this->Find(layer_name, latest);
     } else {
-        for (std::size_t i = 0, n = this->selected_layers.size(); i < n; ++i) {
-            if (this->selected_layers[i].enabled == false) {
-                continue;
-            }
-            if (this->selected_layers[i].key != layer_name) {
-                continue;
-            }
-            if (this->selected_layers[i].api_version != layer_version) {
+        const Layer *newest = this->FindLastModified(layer_name, layer_version);
+
+        if (newest != nullptr) {
+            return newest;
+        } else {
+            // Version not found, search for the latest available
+            return this->Find(layer_name, Version::LATEST);
+        }
+    }
+
+    return nullptr;
+}
+
+const Layer *LayerManager::FindLastModified(const std::string &layer_name, const Version &version) const {
+    const Layer *result = nullptr;
+
+    for (std::size_t i = 0, n = this->selected_layers.size(); i < n; ++i) {
+        if (this->selected_layers[i].enabled == false) {
+            continue;
+        }
+        if (this->selected_layers[i].key != layer_name) {
+            continue;
+        }
+        if (this->selected_layers[i].api_version != version) {
+            continue;
+        }
+        if (result != nullptr) {
+            if (result->validated_last_modified > this->selected_layers[i].validated_last_modified) {
                 continue;
             }
-
-            return &this->selected_layers[i];
         }
 
-        // Version not found, search for the latest available
-        return this->Find(layer_name, Version::LATEST);
+        result = &this->selected_layers[i];
     }
 
-    return nullptr;
+    return result;
 }
 
 const Layer *LayerManager::FindFromManifest(const Path &manifest_path) const {

vkconfig_core/layer_manager.h

@@ -39,8 +39,10 @@ class LayerManager : public Serialize {
     bool Empty() const;
     std::size_t Size() const;
 
+    std::vector<Path> GatherManifests(const std::string& layer_name) const;
     std::vector<Version> GatherVersions(const std::string& layer_name) const;
     const Layer* Find(const std::string& layer_name, const Version& version = Version::LATEST) const;
+    const Layer* FindLastModified(const std::string& layer_name, const Version& version) const;
     const Layer* FindFromManifest(const Path& manifest_path) const;
     Layer* FindFromManifest(const Path& manifest_path);
 

vkconfig_core/test/test_configuration.cpp

@@ -259,17 +259,20 @@ TEST(test_configuration, SwitchLayerVersion) {
     Parameter* parameter_latest = configuration.Find("VK_LAYER_LUNARG_version");
     EXPECT_EQ(parameter_latest->api_version, Version::LATEST);
 
-    configuration.SwitchLayerVersion(layer_manager, "VK_LAYER_LUNARG_version", Version(1, 3, 204));
+    const Layer* layer_204 = layer_manager.Find("VK_LAYER_LUNARG_version", Version(1, 3, 204));
+    configuration.SwitchLayerVersion(layer_manager, "VK_LAYER_LUNARG_version", layer_204->manifest_path);
     Parameter* parameter_204 = configuration.Find("VK_LAYER_LUNARG_version");
     EXPECT_EQ(parameter_204->api_version, Version(1, 3, 204));
 
-    configuration.SwitchLayerVersion(layer_manager, "VK_LAYER_LUNARG_version", Version::LATEST);
+    const Layer* layer_latest = layer_manager.Find("VK_LAYER_LUNARG_version", Version::LATEST);
+    configuration.SwitchLayerLatest(layer_manager, "VK_LAYER_LUNARG_version");
     Parameter* parameter_restore = configuration.Find("VK_LAYER_LUNARG_version");
     EXPECT_EQ(parameter_restore->api_version, Version::LATEST);
 
-    configuration.SwitchLayerVersion(layer_manager, "VK_LAYER_LUNARG_version", Version(1, 3, 205));
+    const Layer* layer_205 = layer_manager.Find("VK_LAYER_LUNARG_version", Version(1, 3, 205));
+    configuration.SwitchLayerVersion(layer_manager, "VK_LAYER_LUNARG_version", layer_205->manifest_path);
     Parameter* parameter_version_not_found = configuration.Find("VK_LAYER_LUNARG_version");
-    EXPECT_EQ(parameter_version_not_found->api_version, Version::LATEST);
+    EXPECT_EQ(parameter_version_not_found->api_version, Version(1, 3, 290));
 }
 
 TEST(test_configuration, gather_parameters_exist) {

vkconfig_gui/main.cpp

@@ -55,6 +55,9 @@ int main(int argc, char* argv[]) {
         }
     }
 
+    Configurator& configurator = Configurator::Get();
+    configurator.Surrender(OVERRIDE_AREA_LOADER_SETTINGS_BIT);
+
     const VulkanSystemInfo& vulkan_info = BuildVulkanSystemInfo();
 
     if (vulkan_info.loaderVersion == Version::NONE) {
@@ -72,9 +75,6 @@ int main(int argc, char* argv[]) {
         return -1;
     }
 
-    Configurator& configurator = Configurator::Get();
-    // configurator.Surrender(OVERRIDE_AREA_LOADER_SETTINGS_BIT);
-
     if (!configurator.Init()) {
         return -1;
     }

vkconfig_gui/settings_tree.cpp

@@ -93,7 +93,7 @@ void SettingsTreeManager::CreateGUI() {
         this->ui->configurations_presets->setVisible(!layer->presets.empty());
     }
 
-    const std::vector<Version> &layer_version = configurator.layers.GatherVersions(parameter->key);
+    const std::vector<Path> &layer_version = configurator.layers.GatherManifests(parameter->key);
     this->layer_version->setVisible(layer_version.size() > 1);
     if (layer_version.size() > 1) {
         this->layer_version->Init(*parameter, layer_version);

vkconfig_gui/widget_layer_version.cpp

@@ -30,7 +30,7 @@ LayerVersionComboBox::LayerVersionComboBox(QWidget *parent) : QComboBox(parent),
     this->connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(on_layer_version_combobox_currentIndexChanged(int)));
 }
 
-void LayerVersionComboBox::Init(const Parameter &parameter, const std::vector<Version> &layer_versions) {
+void LayerVersionComboBox::Init(const Parameter &parameter, const std::vector<Path> &layer_versions) {
     const Configurator &configurator = Configurator::Get();
     const Layer *layer_select = configurator.layers.Find(parameter.key, parameter.api_version);
     const Layer *layer_latest = configurator.layers.Find(parameter.key, Version::LATEST);
@@ -41,44 +41,52 @@ void LayerVersionComboBox::Init(const Parameter &parameter, const std::vector<Ve
     this->addItem("Latest");
     this->setItemData(0, layer_latest->manifest_path.AbsolutePath().c_str(), Qt::ToolTipRole);
 
+    this->data.push_back(layer_latest->manifest_path);
+
     int version_index = 0;
     for (std::size_t i = 0, n = layer_versions.size(); i < n; ++i) {
-        if (layer_versions[i] == parameter.api_version) {
+        if (layer_versions[i] == parameter.manifest) {
             version_index = this->count();
         }
 
-        const Layer *layer_version = configurator.layers.Find(parameter.key, layer_versions[i]);
+        const Layer *layer_version = configurator.layers.FindFromManifest(layer_versions[i]);
 
         const int current_index = this->count();
 
-        this->addItem(layer_versions[i].str().c_str());
+        this->addItem(layer_version->api_version.str().c_str());
         this->setItemData(current_index, layer_version->manifest_path.AbsolutePath().c_str(), Qt::ToolTipRole);
+
+        this->data.push_back(layer_version->manifest_path);
     }
 
-    this->setCurrentIndex(version_index);
+    if (parameter.api_version != Version::LATEST) {
+        this->setCurrentIndex(version_index);
+    }
 
     this->blockSignals(false);
 
     if (layer_select != nullptr) {
         this->setToolTip(layer_select->manifest_path.AbsolutePath().c_str());
-        this->setToolTip(layer_select->description.c_str());
     }
 
     this->adjustSize();
 }
 
 void LayerVersionComboBox::on_layer_version_combobox_currentIndexChanged(int index) {
     assert(index >= 0);
-    const std::string &text = this->itemText(index).toStdString();
-    Version version = text == "Latest" ? Version::LATEST : Version(text.c_str());
-    assert(version != Version::NONE);
+
+    Path path = index > 0 ? this->data[index] : "";
 
     Configurator &configurator = Configurator::Get();
 
     Configuration *configuration = configurator.GetActiveConfiguration();
-    configuration->SwitchLayerVersion(configurator.layers, configuration->GetActiveParameter()->key, version);
+    if (index == 0) {  // latest
+        configuration->SwitchLayerLatest(configurator.layers, configuration->GetActiveParameter()->key);
+    } else {
+        configuration->SwitchLayerVersion(configurator.layers, configuration->GetActiveParameter()->key, path);
+    }
 
-    const Layer *layer = configurator.layers.Find(configuration->GetActiveParameter()->key, version);
+    const Layer *layer = configurator.layers.FindFromManifest(this->data[index]);
     assert(layer != nullptr);
     this->setToolTip(layer->manifest_path.AbsolutePath().c_str());
 

vkconfig_gui/widget_layer_version.h

@@ -31,7 +31,7 @@ class LayerVersionComboBox : public QComboBox {
    public:
     LayerVersionComboBox(QWidget *parent);
 
-    void Init(const Parameter &parameter, const std::vector<Version> &layer_versions);
+    void Init(const Parameter &parameter, const std::vector<Path> &layer_versions);
 
     bool eventFilter(QObject *o, QEvent *e) override;
 
@@ -43,4 +43,5 @@ class LayerVersionComboBox : public QComboBox {
 
    private:
     QWidget *parent = nullptr;
+    std::vector<Path> data;
 };