feat(ui): cleaned uninstalled feature missing ini message, added "required-version" based on cs version

src/Feature.cpp

@@ -26,6 +26,7 @@
 #include "Features/VolumetricLighting.h"
 #include "Features/WaterEffects.h"
 #include "Features/WetnessEffects.h"
+#include "Utils/Format.h"
 
 #include "State.h"
 
@@ -42,21 +43,43 @@ void Feature::Load(json& o_json)
 	SI_Error rc = ini.LoadFile(ini_path.c_str());
 
 	if (rc < 0) {
-		if (!FeatureIssues::IsObsoleteFeature(GetShortName()))
+		if (FeatureIssues::IsObsoleteFeature(GetShortName())) {
+			// Handle obsolete features
+			version = "obsolete";  // Set version so it shows error color in UI
+			failedLoadedMessage = std::format("{} is an obsolete feature that has been removed.", GetShortName());
+			FeatureIssues::FeatureFileInfo fileInfo = FeatureIssues::GetFeatureFileInfo(GetShortName());
+			FeatureIssues::AddFeatureIssue(GetShortName(), "N/A", failedLoadedMessage,
+				FeatureIssues::FeatureIssueInfo::IssueType::OBSOLETE, fileInfo, "");
+		} else {
 			logger::info("{} failed to load, feature disabled", ini_filename);
+
+			// Set error message for missing file
+			std::string requiredVersion = "Unknown";
+			auto iter = FeatureVersions::FEATURE_MINIMAL_VERSIONS.find(GetShortName());
+			if (iter != FeatureVersions::FEATURE_MINIMAL_VERSIONS.end()) {
+				requiredVersion = Util::CleanVersionString(iter->second.string());
+			}
+			failedLoadedMessage = std::format("The {} file is missing. This feature is not installed! Version required: {}", ini_filename, requiredVersion);
+
+			// Add to feature issues
+			FeatureIssues::FeatureFileInfo fileInfo = FeatureIssues::GetFeatureFileInfo(GetShortName());
+			FeatureIssues::AddFeatureIssue(GetShortName(), "unknown", failedLoadedMessage,
+				FeatureIssues::FeatureIssueInfo::IssueType::VERSION_MISMATCH, fileInfo, requiredVersion);
+		}
 		loaded = false;
 		return;
 	}
 
 	bool hasError = false;
 	std::string errorVersion;
+	std::string requiredVersion = "Unknown";  // Store required version for later use
 	FeatureIssues::FeatureIssueInfo::IssueType errorType = FeatureIssues::FeatureIssueInfo::IssueType::UNKNOWN;
-
 	if (FeatureIssues::IsObsoleteFeature(GetShortName())) {
 		hasError = true;
+		version = "obsolete";  // Set version so it shows error color in UI
 		errorVersion = "N/A";
 		errorType = FeatureIssues::FeatureIssueInfo::IssueType::OBSOLETE;
-		failedLoadedMessage = std::format("{} is an obsolete feature that has been removed", GetShortName());
+		failedLoadedMessage = std::format("{} is an obsolete feature that has been removed.", GetShortName());
 	} else if (auto value = ini.GetValue("Info", "Version")) {
 		try {
 			REL::Version featureVersion(std::regex_replace(value, std::regex("-"), "."));
@@ -71,6 +94,8 @@ void Feature::Load(json& o_json)
 			} else {
 				// Version compatibility check
 				auto& minimalFeatureVersion = iter->second;
+				std::string rawVersion = minimalFeatureVersion.string();
+				requiredVersion = Util::CleanVersionString(rawVersion);
 				bool oldFeature = featureVersion.compare(minimalFeatureVersion) == std::strong_ordering::less;
 				bool majorVersionMismatch = featureVersion.major() < minimalFeatureVersion.major();
 
@@ -82,8 +107,7 @@ void Feature::Load(json& o_json)
 					errorVersion = value;
 					errorType = FeatureIssues::FeatureIssueInfo::IssueType::VERSION_MISMATCH;
 
-					std::string minimalVersionString = minimalFeatureVersion.string();
-					minimalVersionString = minimalVersionString.substr(0, minimalVersionString.size() - 2);
+					std::string minimalVersionString = Util::CleanVersionString(minimalFeatureVersion.string());
 
 					if (majorVersionMismatch) {
 						failedLoadedMessage = std::format("{} {} is too old, major version incompatibility detected. Required: {}", GetShortName(), value, minimalVersionString);
@@ -100,11 +124,6 @@ void Feature::Load(json& o_json)
 			errorType = FeatureIssues::FeatureIssueInfo::IssueType::VERSION_MISMATCH;
 			failedLoadedMessage = std::format("{} {} has invalid version format: {}", GetShortName(), value, e.what());
 		}
-	} else {
-		hasError = true;
-		errorVersion = "unknown";
-		errorType = FeatureIssues::FeatureIssueInfo::IssueType::VERSION_MISMATCH;
-		failedLoadedMessage = std::format("{} missing version info; not successfully loaded", ini_filename);
 	}
 
 	if (hasError) {
@@ -181,7 +200,7 @@ bool Feature::ValidateCache(CSimpleIniA& a_ini)
 			logger::info("Change in version detected. Installed {} but {} in Disk Cache", version, versionInCache);
 			return false;
 		} else {
-			logger::info("Installed version and cached version match.");
+			logger::info("Installed version and cached version match");
 		}
 	}
 
@@ -262,4 +281,4 @@ bool Feature::ToggleAtBootSetting()
 	state->SetFeatureDisabled(featureName, !disabled);
 
 	return state->IsFeatureDisabled(featureName);  // Return the new state
-}
+}

src/Feature.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Menu.h"
+#include "Utils/Format.h"
 
 struct Feature
 {
@@ -57,8 +58,11 @@ struct Feature
 
 	/**
 	 * Whether to print the INI version missing message when this feature is unloaded
+	 * Default false to prevent duplicate error messages. This is handled by failedLoadedMessage in Feature.cpp.
+	 * Retains functionality for author to include custom error message.
+	 * Set to "true" in header file of individual feature.
 	 */
-	virtual bool DrawFailLoadMessage() const { return true; }
+	virtual bool DrawFailLoadMessage() const { return false; }
 
 	/**
 	 * Get feature summary and key features for hover tooltip and unloaded UI
@@ -69,28 +73,27 @@ struct Feature
 
 	virtual void SetupResources() {}
 	virtual void Reset() {}
-
 	virtual void DrawSettings() {}
 	virtual void DrawUnloadedUI()
 	{
 		auto [description, keyFeatures] = GetFeatureSummary();
 
-		if (!description.empty() || !keyFeatures.empty()) {
-			ImGui::TextColored(Menu::GetSingleton()->GetTheme().StatusPalette.Error, "This feature is not installed!");
+		if (!failedLoadedMessage.empty()) {
+			ImGui::TextColored(Menu::GetSingleton()->GetTheme().StatusPalette.Error, "%s", failedLoadedMessage.c_str());
 			ImGui::Spacing();
+		}
 
-			if (!description.empty()) {
-				ImGui::TextWrapped("%s", description.c_str());
-				ImGui::Spacing();
-			}
+		if (!description.empty()) {
+			ImGui::TextWrapped("%s", description.c_str());
+			ImGui::Spacing();
+		}
 
-			if (!keyFeatures.empty()) {
-				ImGui::TextWrapped("Key features:");
-				for (const auto& feature : keyFeatures) {
-					ImGui::BulletText("%s", feature.c_str());
-				}
-				ImGui::Spacing();
+		if (!keyFeatures.empty()) {
+			ImGui::TextWrapped("Key features:");
+			for (const auto& feature : keyFeatures) {
+				ImGui::BulletText("%s", feature.c_str());
 			}
+			ImGui::Spacing();
 		}
 	}
 

src/FeatureIssues.cpp

@@ -4,6 +4,7 @@
 #include "Menu.h"
 #include "State.h"
 #include "Util.h"
+#include "Utils/Format.h"
 
 namespace FeatureIssues
 {
@@ -484,11 +485,11 @@ namespace FeatureIssues
 				ImGui::Spacing();
 			}
 			if (!issue.version.empty()) {
-				ImGui::TextWrapped("Current Version: %s", issue.version.c_str());
+				ImGui::TextWrapped("Current Version: %s", Util::CleanVersionString(issue.version).c_str());
 				ImGui::Spacing();
 			}
 			if (issue.IsVersionMismatch() && !issue.minimumVersionRequired.empty()) {
-				ImGui::TextWrapped("Minimum Required: %s", issue.minimumVersionRequired.c_str());
+				ImGui::TextWrapped("Minimum Required: %s", Util::CleanVersionString(issue.minimumVersionRequired).c_str());
 				ImGui::Spacing();
 			}
 			ImGui::TextWrapped("Issue: %s", issue.rejectionReason.c_str());
@@ -577,15 +578,15 @@ namespace FeatureIssues
 			if (!issue.replacementFeatureModLink.empty()) {
 				std::string buttonText = issue.minimumVersionRequired.empty() ?
 				                             ("Download Latest " + issue.replacementFeatureDisplayName) :
-				                             ("Download " + issue.replacementFeatureDisplayName + " " + issue.minimumVersionRequired + "+");
+				                             ("Download " + issue.replacementFeatureDisplayName + " " + Util::CleanVersionString(issue.minimumVersionRequired) + "+");
 
 				if (ImGui::SmallButton(buttonText.c_str())) {
 					ShellExecuteA(0, 0, issue.replacementFeatureModLink.c_str(), 0, 0, SW_SHOW);
 				}
 
 				if (auto _tt = Util::HoverTooltipWrapper()) {
 					if (!issue.minimumVersionRequired.empty()) {
-						ImGui::Text("Download %s version %s or later", issue.replacementFeatureDisplayName.c_str(), issue.minimumVersionRequired.c_str());
+						ImGui::Text("Download %s version %s or later", issue.replacementFeatureDisplayName.c_str(), Util::CleanVersionString(issue.minimumVersionRequired).c_str());
 					} else {
 						ImGui::Text("Download the latest version of %s", issue.replacementFeatureDisplayName.c_str());
 					}
@@ -594,12 +595,12 @@ namespace FeatureIssues
 				// Show message when no download link is available
 				std::string updateText = issue.minimumVersionRequired.empty() ?
 				                             "Update Required" :
-				                             ("Update to " + issue.minimumVersionRequired + "+ Required");
+				                             ("Update to " + Util::CleanVersionString(issue.minimumVersionRequired) + "+ Required");
 
 				ImGui::TextWrapped("%s", updateText.c_str());
 				if (auto _tt = Util::HoverTooltipWrapper()) {
 					if (!issue.minimumVersionRequired.empty()) {
-						ImGui::Text("This feature needs to be updated to version %s or later. Check the mod page manually.", issue.minimumVersionRequired.c_str());
+						ImGui::Text("This feature needs to be updated to version %s or later. Check the mod page manually.", Util::CleanVersionString(issue.minimumVersionRequired).c_str());
 					} else {
 						ImGui::Text("This feature needs to be updated but no download link is available. Check the mod page manually.");
 					}

src/Features/TerrainHelper.cpp

@@ -3,26 +3,6 @@
 #include "ShaderCache.h"
 #include "State.h"
 
-void TerrainHelper::DrawUnloadedUI()
-{
-	auto [description, keyFeatures] = GetFeatureSummary();
-
-	ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
-	ImGui::Text("%s", description.c_str());
-
-	if (!keyFeatures.empty()) {
-		ImGui::Spacing();
-		ImGui::Text("Key Features:");
-		for (const auto& feature : keyFeatures) {
-			ImGui::BulletText("%s", feature.c_str());
-		}
-	}
-
-	ImGui::Spacing();
-	ImGui::TextWrapped("Note: This feature is only required if a terrain mod you are using specifically requires it, otherwise it does nothing.");
-	ImGui::PopTextWrapPos();
-}
-
 void TerrainHelper::DataLoaded()
 {
 	// Get the default landscape texture set for terrain helper

src/Features/TerrainHelper.h

@@ -20,7 +20,7 @@ struct TerrainHelper : Feature
 	virtual std::pair<std::string, std::vector<std::string>> GetFeatureSummary() override
 	{
 		return {
-			"Provides enhanced terrain material support for terrain mods that require additional texture slots and parallax mapping capabilities.",
+			"Provides enhanced terrain material support for terrain mods that require additional texture slots and parallax mapping capabilities.\nNote: This feature is only required if a terrain mod you are using specifically requires it, otherwise it does nothing.",
 			{ "Extended texture slot support for terrain materials",
 				"Parallax mapping integration for terrain textures",
 				"Automatic terrain material detection and setup",
@@ -45,8 +45,6 @@ struct TerrainHelper : Feature
 	virtual void DataLoaded() override;
 	virtual bool SupportsVR() override { return true; };
 	virtual std::string GetFeatureModLink() override { return MakeNexusModURL(MOD_ID); }
-	virtual void DrawUnloadedUI() override;
-	virtual bool DrawFailLoadMessage() const override { return false; };
 
 	void SetShaderResouces(ID3D11DeviceContext* a_context);
 	bool TESObjectLAND_SetupMaterial(RE::TESObjectLAND* land);

src/Features/TerrainVariation.cpp

@@ -135,9 +135,4 @@ void TerrainVariation::LoadSettings(json& o_json)
 void TerrainVariation::SaveSettings(json& o_json)
 {
 	o_json = settings;
-}
-
-bool TerrainVariation::DrawFailLoadMessage() const
-{
-	return false;
 }

src/Features/TerrainVariation.h

@@ -25,7 +25,7 @@ struct TerrainVariation : Feature
 		return {
 			"Terrain Variation reduces the repeating pattern effect on terrain textures.\n"
 			"This technique creates more natural-looking terrain by adding variation to texture sampling.",
-			{ "Reduces terrain texture tiling",
+			{ "Removes terrain texture tiling",
 				"Adjustable distance-based blending",
 				"Improved terrain visual quality",
 				"Compatible with Extended Materials parallax" }
@@ -56,9 +56,7 @@ struct TerrainVariation : Feature
 		1.0f,      // shadowRayDirFactor
 		1          // hashQuality - default to high quality
 	};
-
 	virtual void DrawSettings() override;
-	virtual bool DrawFailLoadMessage() const override;
 	virtual void LoadSettings(json& o_json) override;
 	virtual void SaveSettings(json& o_json) override;
 	virtual void RestoreDefaultSettings() override

src/Menu.cpp

@@ -564,10 +564,6 @@ void Menu::DrawSettings()
 						ImGui::EndTable();
 					}
 
-					if (hasFailedMessage && feat->DrawFailLoadMessage()) {
-						ImGui::TextColored(themeSettings.StatusPalette.Error, feat->failedLoadedMessage.c_str());
-					}
-
 					if (!isDisabled) {
 						if (ImGui::BeginChild("##FeatureConfigFrame", { 0, 0 }, true)) {
 							if (isLoaded) {

src/Utils/Format.cpp

@@ -8,6 +8,14 @@ namespace Util
 		return v.substr(0, v.find_last_of("."));
 	}
 
+	std::string CleanVersionString(const std::string& versionString)
+	{
+		if (versionString.size() >= 2 && versionString.substr(versionString.size() - 2) == "-0") {
+			return versionString.substr(0, versionString.size() - 2);
+		}
+		return versionString;
+	}
+
 	std::string DefinesToString(const std::vector<std::pair<const char*, const char*>>& defines)
 	{
 		std::string result;

src/Utils/Format.h

@@ -6,6 +6,8 @@ namespace Util
 {
 	std::string GetFormattedVersion(const REL::Version& version);
 
+	std::string CleanVersionString(const std::string& versionString);
+
 	std::string DefinesToString(const std::vector<std::pair<const char*, const char*>>& defines);
 	std::string DefinesToString(const std::vector<D3D_SHADER_MACRO>& defines);