✨ Add AvailableRuntimes to reports

Author: fredemmott

src/Platform.cpp

@@ -12,36 +12,50 @@ namespace FredEmmott::OpenXRLayers {
 
 namespace {
 std::optional<Runtime> GetRuntimeFromPath(const std::filesystem::path& path) {
-  using enum Runtime::ManifestError;
-
   if (path.empty()) {
     return {};
   }
+  return Runtime(path);
+}
 
+std::expected<std::string, Runtime::ManifestError> GetRuntimeName(
+  const std::filesystem::path& path) {
+  using enum Runtime::ManifestError;
   try {
     if (!std::filesystem::exists(path)) {
-      return Runtime {path, std::unexpected {FileNotFound}};
+      return std::unexpected {FileNotFound};
     }
 
     std::ifstream f(path);
     if (!f) {
-      return Runtime {path, std::unexpected {FileNotReadable}};
+      return std::unexpected {FileNotReadable};
     }
 
     const auto json = nlohmann::json::parse(f);
     if (json.contains("runtime") && json.at("runtime").contains("name")) {
-      return Runtime {path, json.at("runtime").at("name")};
+      return json.at("runtime").at("name");
     }
 
-    return Runtime {path, std::unexpected {FieldNotPresent}};
-  } catch (const std::filesystem::filesystem_error& e) {
-    return Runtime {path, std::unexpected {FileNotReadable}};
-  } catch (const nlohmann::json::exception& e) {
-    return Runtime {path, std::unexpected {InvalidJson}};
+    return std::unexpected {FieldNotPresent};
+  } catch (const std::filesystem::filesystem_error&) {
+    return std::unexpected {FileNotReadable};
+  } catch (const nlohmann::json::exception&) {
+    return std::unexpected {InvalidJson};
   }
 }
+
 }// namespace
 
+Runtime::Runtime(const std::filesystem::path& path)
+  : mPath(path),
+    mName(GetRuntimeName(path)) {}
+
+AvailableRuntime::AvailableRuntime(
+  const std::filesystem::path& path,
+  const Discoverability discoverability)
+  : Runtime(path),
+    mDiscoverability(discoverability) {}
+
 Platform::Platform() = default;
 Platform::~Platform() = default;
 

src/Platform.hpp

@@ -27,10 +27,26 @@ struct Runtime {
     FieldNotPresent,
   };
 
+  Runtime() = delete;
+  explicit Runtime(const std::filesystem::path& path);
+
   std::filesystem::path mPath;
   std::expected<std::string, ManifestError> mName;
 };
 
+struct AvailableRuntime : Runtime {
+  enum class Discoverability {
+    Discoverable,
+    Hidden,
+    Win32_NotDWORD,
+  };
+
+  AvailableRuntime() = delete;
+  AvailableRuntime(const std::filesystem::path& path, Discoverability);
+
+  Discoverability mDiscoverability;
+};
+
 // Platform-specific functions implemented in PlatformGUI_P*.cpp
 class Platform {
  public:
@@ -48,6 +64,9 @@ class Platform {
   virtual std::unordered_set<std::string> GetEnvironmentVariableNames() = 0;
   virtual float GetDPIScaling() = 0;
 
+  virtual std::vector<AvailableRuntime> GetAvailable32BitRuntimes() = 0;
+  virtual std::vector<AvailableRuntime> GetAvailable64BitRuntimes() = 0;
+
   // Use OS/environment equivalent to Explorer
   virtual void ShowFolderContainingFile(const std::filesystem::path&) = 0;
 

src/SaveReport.cpp

@@ -114,7 +114,7 @@ static std::string GenerateReportText(const APILayerStore* store) {
   return ret;
 }
 
-static std::string GenerateRuntimeText(
+static std::string GenerateActiveRuntimeText(
   const uint8_t bitness,
   const std::optional<Runtime>& runtime) {
   if (!runtime) {
@@ -139,6 +139,51 @@ static std::string GenerateRuntimeText(
     runtime->mPath.string());
 }
 
+static std::string GenerateAvailableRuntimesText(
+  const uint8_t bitness,
+  const std::vector<AvailableRuntime>& runtimes) {
+  auto ret = std::format("\nAvailable {}-bit runtimes:\n", bitness);
+  if (runtimes.empty()) {
+    return ret + "  NONE\n";
+  }
+
+  for (auto&& runtime: runtimes) {
+    if (runtime.mName) {
+      ret += fmt::format(
+        "  - \"{}\" - {}", runtime.mName.value(), runtime.mPath.string());
+    } else {
+      using enum Runtime::ManifestError;
+      switch (runtime.mName.error()) {
+        case FieldNotPresent:
+          ret += fmt::format("  - {}", runtime.mPath.string());
+          break;
+        case FileNotFound:
+          ret += fmt::format("  - ❌ FILE MISSING: {}", runtime.mPath.string());
+          break;
+        case FileNotReadable:
+        case InvalidJson:
+          ret += fmt::format(
+            "  - ❌ FILE NOT READABLE: {}", runtime.mPath.string());
+          break;
+      }
+    }
+
+    switch (runtime.mDiscoverability) {
+      case AvailableRuntime::Discoverability::Discoverable:
+        ret += " (discoverable)\n";
+        break;
+      case AvailableRuntime::Discoverability::Hidden:
+        ret += " (disabled)\n";
+        break;
+      case AvailableRuntime::Discoverability::Win32_NotDWORD:
+        ret += " (🚨 NOT A DWORD)\n";
+        break;
+    }
+  }
+
+  return ret;
+}
+
 void SaveReport(const std::filesystem::path& path) {
   auto text = std::format(
     "OpenXR API Layers GUI v{}\n"
@@ -148,8 +193,13 @@ void SaveReport(const std::filesystem::path& path) {
       std::chrono::current_zone(), std::chrono::system_clock::now()));
 
   auto& platform = Platform::Get();
-  text += GenerateRuntimeText(64, platform.Get64BitRuntime());
-  text += GenerateRuntimeText(32, platform.Get32BitRuntime());
+  text += GenerateActiveRuntimeText(64, platform.Get64BitRuntime());
+  text += GenerateActiveRuntimeText(32, platform.Get32BitRuntime());
+
+  text
+    += GenerateAvailableRuntimesText(64, platform.GetAvailable64BitRuntimes());
+  text
+    += GenerateAvailableRuntimesText(32, platform.GetAvailable64BitRuntimes());
 
   for (const auto store: APILayerStore::Get()) {
     text += GenerateReportText(store);

src/windows/WindowsPlatform.cpp

@@ -7,6 +7,7 @@
 #include <Windows.h>
 
 #include <wil/com.h>
+#include <wil/registry.h>
 #include <wil/resource.h>
 
 #include <nlohmann/json.hpp>
@@ -41,17 +42,55 @@ extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
 namespace FredEmmott::OpenXRLayers {
 
 namespace {
+
+std::vector<AvailableRuntime> GetAvailableRuntimes(const REGSAM bitness) {
+  const REGSAM desiredAccess = bitness | KEY_READ;
+  wil::unique_hkey hkey;
+  RegOpenKeyExW(
+    HKEY_LOCAL_MACHINE,
+    L"SOFTWARE\\Khronos\\OpenXR\\1\\AvailableRuntimes",
+    0,
+    desiredAccess,
+    hkey.put());
+  if (!hkey) {
+    return {};
+  }
+
+  std::vector<AvailableRuntime> ret;
+  using enum AvailableRuntime::Discoverability;
+  for (auto&& it: wil::make_range(
+         wil::reg::value_iterator {hkey.get()}, wil::reg::value_iterator {})) {
+    if (it.type != REG_DWORD) {
+      ret.emplace_back(it.name, Win32_NotDWORD);
+      continue;
+    }
+
+    DWORD value {};
+    DWORD valueSize {sizeof(value)};
+    RegGetValueW(
+      hkey.get(),
+      nullptr,
+      it.name.c_str(),
+      RRF_RT_DWORD,
+      nullptr,
+      &value,
+      &valueSize);
+    ret.emplace_back(it.name, (value == 0) ? Discoverable : Hidden);
+  }
+  return ret;
+}
+
 static LSTATUS
 GetActiveRuntimePath(const REGSAM desiredAccess, void* data, DWORD* dataSize) {
-  wil::unique_hkey hKey;
+  wil::unique_hkey hkey;
   RegOpenKeyExW(
     HKEY_LOCAL_MACHINE,
     L"SOFTWARE\\Khronos\\OpenXR\\1",
     0,
     desiredAccess,
-    hKey.put());
+    hkey.put());
   return RegGetValueW(
-    hKey.get(),
+    hkey.get(),
     nullptr,
     L"ActiveRuntime",
     RRF_RT_REG_SZ,
@@ -276,6 +315,14 @@ std::unordered_set<std::string> WindowsPlatform::GetEnvironmentVariableNames() {
   return ret;
 }
 
+std::vector<AvailableRuntime> WindowsPlatform::GetAvailable32BitRuntimes() {
+  return GetAvailableRuntimes(KEY_WOW64_32KEY);
+}
+
+std::vector<AvailableRuntime> WindowsPlatform::GetAvailable64BitRuntimes() {
+  return GetAvailableRuntimes(KEY_WOW64_64KEY);
+}
+
 HWND WindowsPlatform::CreateAppWindow() {
   static const auto WindowTitle
     = std::format(L"OpenXR API Layers v{}", Config::BUILD_VERSION_W);

src/windows/WindowsPlatform.hpp

@@ -28,6 +28,10 @@ class WindowsPlatform final : public Platform {
   void ShowFolderContainingFile(const std::filesystem::path& path) override;
   std::unordered_set<std::string> GetEnvironmentVariableNames() override;
 
+  std::vector<AvailableRuntime> GetAvailable32BitRuntimes() override;
+  std::vector<AvailableRuntime> GetAvailable64BitRuntimes() override;
+
+ protected:
   std::filesystem::path Get32BitRuntimePath() override;
   std::filesystem::path Get64BitRuntimePath() override;