.github/workflows/build-package.yml

@@ -12,14 +12,12 @@ jobs:
       - name: Install build tools
         run: |
           set -x
-          sudo dpkg --add-architecture i386
-          curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
-          echo "deb [signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages focal main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+          dpkg --add-architecture i386
           sudo apt update
           sudo apt -y install gcc-multilib g++-multilib ninja-build python3-setuptools \
                               python3-wheel mesa-common-dev libxnvctrl-dev libdbus-1-dev \
                               python3-numpy python3-matplotlib unzip hub libxkbcommon-dev libwayland-dev wget unzip \
-                              libxkbcommon-dev:i386 libwayland-dev:i386 gh
+                              libxkbcommon-dev:i386 libwayland-dev:i386
           sudo pip3 --no-input install 'meson>=0.60' mako
           wget https://github.com/KhronosGroup/glslang/releases/download/SDK-candidate-26-Jul-2020/glslang-master-linux-Release.zip
           unzip glslang-master-linux-Release.zip bin/glslangValidator
@@ -37,25 +35,32 @@ jobs:
           else
             echo "##[set-output name=short-sha;]$(git rev-parse --short "$GITHUB_SHA")"
           fi
-          echo "##[set-output name=artifact-metadata;]$ARTIFACT_NAME"
-      - name: Build and package
+          echo "##[set-output name=artifact-metadata;]${ARTIFACT_NAME}"
+        id: git-vars
+      - name: Build release package
         run: |
           ./build-source.sh
           ./build.sh build -Dwerror=true package release
-      - name: Upload assets to release
-        if: github.event.action == 'published'
+      - name: Upload release
+        if: ${{ github.event_name == 'release' && github.event.action == 'published' }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          tag_name="${GITHUB_REF##*/}"
-          for pkg in ./build/*.tar.*; do
-            gh release upload "$tag_name" "$pkg" --clobber
+          set -x
+          assets=()
+          for asset in ./MangoHud-*-Source*.tar.*; do
+            assets+=("-a" "$asset")
           done
-
+          for asset in ./build/MangoHud-*.tar.*; do
+            assets+=("-a" "$asset")
+          done
+          tag_name="${GITHUB_REF##*/}"
+          hub release edit "${assets[@]}" -m "" "$tag_name"
+          #hub release create "${assets[@]}" -m "$tag_name" "$tag_name"
       - name: Upload artifact
         uses: actions/upload-artifact@v3
         continue-on-error: true
         with:
           name: MangoHud-${{steps.git-vars.outputs.artifact-metadata}}
           path: ${{runner.workspace}}/MangoHud/build/MangoHud-*tar.gz
-          retention-days: 30
+          retention-days: 30

build.sh

@@ -54,7 +54,7 @@ dependencies() {
         for i in $DISTRO; do
         echo "# Checking dependencies for \"$i\""
         case $i in
-            *arch*|*manjaro*|*artix*|*SteamOS*)
+            *arch*|*manjaro*|*artix*)
                 MANAGER_QUERY="pacman -Q"
                 MANAGER_INSTALL="pacman -S"
                 DEPS="{${DEPS_ARCH}}"
@@ -73,7 +73,7 @@ dependencies() {
                 break
             ;;
 
-            *debian*|*ubuntu*|*deepin*|*pop*)
+            *debian*|*ubuntu*|*deepin*)
                 MANAGER_QUERY="dpkg-query -s"
                 MANAGER_INSTALL="apt install"
                 DEPS="{${DEPS_DEBIAN}}"

meson.build

@@ -1,6 +1,6 @@
 project('MangoHud',
   ['c', 'cpp'],
-  version : 'v0.7.2',
+  version : 'v0.7.1',
   license : 'MIT',
   meson_version: '>=0.60.0',
   default_options : ['buildtype=release', 'c_std=c99', 'cpp_std=c++14', 'warning_level=2']
@@ -166,18 +166,9 @@ else
   dep_rt = null_dep
 endif
 
-# Commented code can be used if mangohud start using latest SDK Vulkan-Headers
-# Allowing user to build mangohud using system Vulkan-Headers
-#if not dependency('VulkanHeaders').found()
-  vkh_sp = subproject('vulkan-headers')
-  vk_api_xml = vkh_sp.get_variable('vulkan_api_xml')
-  dep_vulkan = vkh_sp.get_variable('vulkan_headers_dep')
-#else
-#  dep_vulkan = dependency('VulkanHeaders', required: true)
-#  vk_api_xml = files('/usr/share/vulkan/registry/vk.xml')
-#endif
-
-
+vkh_sp = subproject('vulkan-headers')
+vk_api_xml = vkh_sp.get_variable('vulkan_api_xml')
+dep_vulkan = vkh_sp.get_variable('vulkan_headers_dep')
 
 vk_enum_to_str = custom_target(
   'vk_enum_to_str',
@@ -222,36 +213,36 @@ if get_option('mangoapp')
     'glfw=enabled',
   ]
 endif
-dearimgui_dep = dependency('imgui', fallback: ['imgui'], required: true, default_options: imgui_options)
+
+dearimgui_sp = subproject('imgui', default_options: imgui_options)
+dearimgui_dep = dearimgui_sp.get_variable('imgui_dep')
 
 if is_unixy
-implot_dep = dependency('implot', fallback: ['implot'], required: true, default_options: ['default_library=static'])
+implot_sp = subproject('implot', default_options: ['default_library=static'])
+implot_dep = implot_sp.get_variable('implot_dep')
 else
 implot_dep = null_dep
 implot_lib = static_library('nulllib', [])
 endif
 
-spdlog_options = [
-  'default_library=static',
-  'compile_library=true',
-  'werror=false',
-  'tests=disabled',
-  'external_fmt=disabled',
-  'std_format=disabled'
-]
-
-spdlog_dep = dependency('spdlog', required: false)
-
-if get_option('use_system_spdlog').disabled() or not spdlog_dep.found()
-    if get_option('use_system_spdlog').enabled()
-      warning('spdlog depedency not found follwing back to submodule')
-    endif
-    spdlog_sp = subproject('spdlog', default_options: spdlog_options)
-    spdlog_dep = spdlog_sp.get_variable('spdlog_dep')
+spdlog_dep = cpp.find_library('spdlog', required: get_option('use_system_spdlog'))
+if not spdlog_dep.found()
+  spdlog_sp = subproject('spdlog', default_options: [
+    'default_library=static',
+    'compile_library=true',
+    'werror=false',
+    'tests=disabled',
+    'external_fmt=disabled',
+    'std_format=disabled'
+  ])
+  spdlog_dep = spdlog_sp.get_variable('spdlog_dep')
+else
+  spdlog_dep = dependency('spdlog', required: true)
 endif
 
 if ['windows', 'mingw'].contains(host_machine.system())
-  minhook_dep = dependency('minhook', fallback: ['minhook', 'minhook_dep'], required: true)
+  minhook_sp = subproject('minhook')
+  minhook_dep = minhook_sp.get_variable('minhook_dep')
   windows_deps = [
     minhook_dep,
   ]
@@ -287,7 +278,6 @@ if get_option('tests').enabled()
       dep_vulkan,
       cmocka_dep,
       spdlog_dep,
-      implot_dep,
       dearimgui_dep
     ],
     include_directories: inc_common)

pkgbuild/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Simon Hallsten <flightlessmangoyt@gmail.com>
 
 pkgname=('mangohud' 'lib32-mangohud')
-pkgver=0.7.2.rc3.r13.g5d744d3
+pkgver=0.7.2.rc1
 pkgrel=1
 pkgdesc="Vulkan and OpenGL overlay to display performance information"
 arch=('x86_64')
@@ -15,8 +15,8 @@ source=(
         "mangohud-minhook"::"git+https://github.com/flightlessmango/minhook.git"
         "imgui-1.89.9.tar.gz::https://github.com/ocornut/imgui/archive/refs/tags/v1.89.9.tar.gz"
         "imgui_1.89.9-1_patch.zip::https://wrapdb.mesonbuild.com/v2/imgui_1.89.9-1/get_patch"
-        "spdlog-1.14.1.tar.gz::https://github.com/gabime/spdlog/archive/refs/tags/v1.14.1.tar.gz"
-        "spdlog_1.14.1-1_patch.zip::https://wrapdb.mesonbuild.com/v2/spdlog_1.14.1-1/get_patch"
+        "spdlog-1.13.0.tar.gz::https://github.com/gabime/spdlog/archive/refs/tags/v1.13.0.tar.gz"
+        "spdlog_1.13.0-1_patch.zip::https://wrapdb.mesonbuild.com/v2/spdlog_1.13.0-1/get_patch"
         "nlohmann_json-3.10.5.zip::https://github.com/nlohmann/json/releases/download/v3.10.5/include.zip"
         "vulkan-headers-1.2.158.tar.gz::https://github.com/KhronosGroup/Vulkan-Headers/archive/v1.2.158.tar.gz"
         "vulkan-headers-1.2.158-2-wrap.zip::https://wrapdb.mesonbuild.com/v2/vulkan-headers_1.2.158-2/get_patch"
@@ -29,8 +29,8 @@ sha256sums=(
             'SKIP'
             '1acc27a778b71d859878121a3f7b287cd81c29d720893d2b2bf74455bf9d52d6'
             '9b21290c597d76bf8d4eeb3f9ffa024b11d9ea6c61e91d648ccc90b42843d584'
-            '1586508029a7d0670dfcb2d97575dcdc242d3868a259742b69f100801ab4e16b'
-            'ae878e732330ea1048f90d7e117c40c0cd2a6fb8ae5492c7955818ce3aaade6c'
+            '534f2ee1a4dcbeb22249856edfb2be76a1cf4f708a20b0ac2ed090ee24cfdbc9'
+            '556b539cf582a46673ede4202ac037b891328dd5ea76862ffe05b060fc4f4775'
             'b94997df68856753b72f0d7a3703b7d484d4745c567f3584ef97c96c25a5798e'
             "53361271cfe274df8782e1e47bdc9e61b7af432ba30acbfe31723f9df2c257f3"
             "860358cf5e73f458cd1e88f8c38116d123ab421d5ce2e4129ec38eaedd820e17"
@@ -53,7 +53,7 @@ prepare() {
 
   # meson subprojects
   ln -sv "$srcdir/imgui-1.89.9" subprojects
-  ln -sv "$srcdir/spdlog-1.14.1" subprojects
+  ln -sv "$srcdir/spdlog-1.13.0" subprojects
   mkdir  subprojects/nlohmann_json-3.10.5
   ln -sv "$srcdir/include" subprojects/nlohmann_json-3.10.5/
   ln -sv "$srcdir/single_include" subprojects/nlohmann_json-3.10.5/

src/blacklist.cpp

@@ -25,7 +25,6 @@ static  std::vector<std::string> blacklist {
     "EpicGamesLauncher.exe",
     "IGOProxy.exe",
     "IGOProxy64.exe",
-    "monado-service",
     "Origin.exe",
     "OriginThinSetupInternal.exe",
     "steam",
@@ -55,9 +54,6 @@ static  std::vector<std::string> blacklist {
     "iexplore.exe",
     "rundll32.exe",
     "Launcher", //Paradox Interactive Launcher
-    "steamwebhelper.exe",
-    "EpicWebHelper.exe",
-    "UplayWebCore.exe"
 };
 
 

src/cpu.cpp

@@ -469,8 +469,7 @@ static bool find_input(const std::string& path, const char* input_prefix, std::s
         if (uscore != std::string::npos) {
             file.erase(uscore, std::string::npos);
             input = path + "/" + file + "_input";
-            //9 characters should not overflow the 32-bit int
-            return std::stoi(read_line(input).substr(0, 9)) > 0;
+            return true;
         }
     }
     return false;

src/cpu.h

@@ -56,7 +56,6 @@ enum {
 };
 
 struct CPUPowerData {
-   virtual ~CPUPowerData() = default;
    int source;
 };
 

src/device.cpp

@@ -6,7 +6,6 @@
 
 namespace fs = ghc::filesystem;
 using namespace std;
-std::mutex device_lock;
 std::vector<device_batt> device_data;
 std::vector<std::string> list;
 bool device_found = false;
@@ -19,7 +18,6 @@ int ds5_count = 0;
 int switch_count = 0;
 int bitdo_count = 0;
 int logi_count = 0; //Logitech devices, mice & keyboards etc.
-int shield_count = 0;
 
 std::string  xbox_paths [2]{"gip","xpadneo"};
 
@@ -30,7 +28,6 @@ static bool operator<(const device_batt& a, const device_batt& b)
 
 
 void device_update(const struct overlay_params& params){
-    std::unique_lock<std::mutex> l(device_lock);
     fs::path path("/sys/class/power_supply");
     list.clear();
     xbox_count = 0;
@@ -38,7 +35,6 @@ void device_update(const struct overlay_params& params){
     ds5_count = 0;
     switch_count = 0;
     bitdo_count = 0;
-    shield_count = 0;
     for (auto &p : fs::directory_iterator(path)) {
         string fileName = p.path().filename();
 //Gamepads
@@ -75,14 +71,7 @@ void device_update(const struct overlay_params& params){
                 device_found = true;
                 bitdo_count += 1;
             }
-            //CHECK NVIDIA SHIELD DEVICES
-            if (fileName.find("thunderstrike") != std::string::npos) {
-                list.push_back(p.path());
-                device_found = true;
-                shield_count += 1;
-            }
-        }
-
+    }
 // Mice and Keyboards
         //CHECK LOGITECH DEVICES
          if (std::find(params.device_battery.begin(), params.device_battery.end(), "mouse") != params.device_battery.end()) {
@@ -97,7 +86,6 @@ void device_update(const struct overlay_params& params){
 
 
 void device_info () {
-    std::unique_lock<std::mutex> l(device_lock);
     device_count = 0;
     device_data.clear();
     //gamepad counters
@@ -106,7 +94,6 @@ void device_info () {
     int ds5_counter = 0;
     int switch_counter = 0;
     int bitdo_counter = 0;
-    int shield_counter = 0;
 
     for (auto &path : list ) {
         //Set devices paths
@@ -165,25 +152,14 @@ void device_info () {
                     device_data[device_count].name = "8BITDO PAD-" + to_string(bitdo_counter + 1);
                 bitdo_counter++;
             }
-            //Shield devices
-            if (path.find("thunderstrike") != std::string::npos) {
-                if (shield_count == 1)
-                    device_data[device_count].name = "SHIELD PAD";
-                else
-                    device_data[device_count].name = "SHIELD PAD-" + to_string(shield_counter + 1);
-                shield_counter++;
-            }
         }
-
 // MICE AND KEYBOARDS
         //Logitech Devices
          if (check_mouse == true) {
             if (path.find("hidpp_battery") != std::string::npos) {
-                // Find a good way truncate name or retreive device type before using this
-                    // if (std::getline(device_name, line)) {
-                    //     device_data[device_count].name = line;
-                    // }
-                device_data[device_count].name = "LOGI MOUSE/KB";
+                if (std::getline(device_name, line)) {
+                    device_data[device_count].name = line;
+                }
             }
          }
 

src/device.h

@@ -14,7 +14,6 @@ struct device_batt {
 };
 
 extern std::vector<device_batt> device_data;
-extern std::mutex device_lock;
 
 extern bool device_found;
 extern int device_count;

src/gl/inject_egl.cpp

@@ -20,7 +20,7 @@ static void* get_egl_proc_address(const char* name) {
     void *func = nullptr;
     static void *(*pfn_eglGetProcAddress)(const char*) = nullptr;
     if (!pfn_eglGetProcAddress) {
-        void *handle = real_dlopen("libEGL.so.1", RTLD_LAZY);
+        void *handle = real_dlopen("libEGL.so.1", RTLD_LAZY|RTLD_LOCAL);
         if (!handle) {
             SPDLOG_ERROR("Failed to open " MANGOHUD_ARCH " libEGL.so.1: {}", dlerror());
         } else {
@@ -35,7 +35,7 @@ static void* get_egl_proc_address(const char* name) {
         func = get_proc_address( name );
 
     if (!func) {
-        SPDLOG_ERROR("Failed to get function '{}'", name);
+        SPDLOG_DEBUG("Failed to get function '{}'", name);
     }
 
     return func;

src/gl/inject_glx.cpp

@@ -107,7 +107,12 @@ EXPORT_C_(void) glXDestroyContext(void *dpy, void *ctx)
 EXPORT_C_(int) glXMakeCurrent(void* dpy, void* drawable, void* ctx) {
     glx.Load();
     SPDLOG_DEBUG("{}: {}, {}", __func__, drawable, ctx);
-    int ret = glx.MakeCurrent(dpy, drawable, ctx);
+    int ret;
+    // This is hack, proper fix should be implemented.
+    // MakeCurrent fails on the minecraft-launcher so we
+    // just bypass it and minecraft hooking works as it should
+    if (get_program_name() != "minecraft-launcher")
+        ret = glx.MakeCurrent(dpy, drawable, ctx);
 
     if (!is_blacklisted()) {
         if (ret) {

src/hook_dlsym.cpp

@@ -15,7 +15,6 @@ EXPORT_C_(void*) dlsym(void * handle, const char * name)
         find_egl_ptr = reinterpret_cast<decltype(find_egl_ptr)> (real_dlsym(RTLD_NEXT, "mangohud_find_egl_ptr"));
 
     void* func = nullptr;
-    bool is_angle = real_dlsym(handle, "eglStreamPostD3DTextureANGLE");
     void* real_func = real_dlsym(handle, name);
 
     if (find_glx_ptr && real_func) {
@@ -26,7 +25,7 @@ EXPORT_C_(void*) dlsym(void * handle, const char * name)
         }
     }
 
-    if (find_egl_ptr && real_func && !is_angle) {
+    if (find_egl_ptr && real_func) {
         func = find_egl_ptr(name);
         if (func) {
             //fprintf(stderr,"%s: local: %s\n",  __func__ , name);

src/hud_elements.cpp

@@ -942,6 +942,7 @@ void HudElements::_exec(){
     ImguiNextColumnFirstItem();
     for (auto& item : HUDElements.exec_list){
         if (item.pos == HUDElements.place){
+            ImguiNextColumnFirstItem();
             right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%s", item.ret.c_str());
         }
     }
@@ -1085,24 +1086,25 @@ void HudElements::gamescope_frame_timing(){
         static double min_time = 0.0f;
         static double max_time = 50.0f;
         if (HUDElements.gamescope_debug_app.size() > 0 && HUDElements.gamescope_debug_app.back() > -1){
+            ImguiNextColumnFirstItem();
+            ImGui::Dummy(ImVec2(0.0f, real_font_size.y));
+            ImGui::PushFont(HUDElements.sw_stats->font1);
+            HUDElements.TextColored(HUDElements.colors.engine, "%s", "App");
+            ImGui::TableNextRow();
+            ImGui::Dummy(ImVec2(0.0f, real_font_size.y));
             auto min = std::min_element(HUDElements.gamescope_debug_app.begin(),
                                         HUDElements.gamescope_debug_app.end());
             auto max = std::max_element(HUDElements.gamescope_debug_app.begin(),
                                         HUDElements.gamescope_debug_app.end());
-            
-            ImGui::PushFont(HUDElements.sw_stats->font1);
-            ImGui::Dummy(ImVec2(0.0f, real_font_size.y));
-            HUDElements.TextColored(HUDElements.colors.engine, "%s", "App");
-            ImGui::TableSetColumnIndex(ImGui::TableGetColumnCount() - 1);
             right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width * 1.3, "min: %.1fms, max: %.1fms", min[0], max[0]);
-            ImGui::Dummy(ImVec2(0.0f, real_font_size.y / 2));
-            ImguiNextColumnFirstItem();
             ImGui::PopFont();
+            ImguiNextColumnFirstItem();
             char hash[40];
             snprintf(hash, sizeof(hash), "##%s", overlay_param_names[OVERLAY_PARAM_ENABLED_frame_timing]);
             HUDElements.sw_stats->stat_selector = OVERLAY_PLOTS_frame_timing;
             HUDElements.sw_stats->time_dividor = 1000000.0f; /* ns -> ms */
 
+
             ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
             if (ImGui::BeginChild("gamescope_app_window", ImVec2(ImGui::GetWindowContentRegionWidth(), 50))) {
                 ImGui::PlotLines("", HUDElements.gamescope_debug_app.data(),
@@ -1144,7 +1146,6 @@ void HudElements::gamescope_frame_timing(){
 void HudElements::device_battery()
 {
 #ifdef __linux__
-    std::unique_lock<std::mutex> l(device_lock);
     if (!HUDElements.params->device_battery.empty()) {
         if (device_found) {
             for (int i = 0; i < device_count; i++) {
@@ -1412,12 +1413,10 @@ void HudElements::hdr() {
 
 void HudElements::refresh_rate() {
     if (HUDElements.refresh > 0) {
-        ImGui::PushFont(HUDElements.sw_stats->font1);
         ImguiNextColumnFirstItem();
         HUDElements.TextColored(HUDElements.colors.engine, "%s", "Display Hz");
         ImguiNextColumnOrNewRow();
         right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%i", HUDElements.refresh);
-        ImGui::PopFont();
     }
 }
 
@@ -1426,12 +1425,10 @@ void HudElements::winesync() {
         HUDElements.winesync_ptr = std::make_unique<WineSync>();
 
     if (HUDElements.winesync_ptr->valid()) {
-        ImGui::PushFont(HUDElements.sw_stats->font1);
         ImguiNextColumnFirstItem();
         HUDElements.TextColored(HUDElements.colors.engine, "%s", "WSYNC");
         ImguiNextColumnOrNewRow();
         right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%s", HUDElements.winesync_ptr->get_method().c_str());
-        ImGui::PopFont();
     }
 }
 
@@ -1455,21 +1452,28 @@ void HudElements::network() {
     if (!HUDElements.net)
         HUDElements.net = std::make_unique<Net>();
 
+    ImguiNextColumnFirstItem();
+    HUDElements.TextColored(HUDElements.colors.network, "%s", "NET");
+    ImGui::TableNextColumn();
+    right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%s", "TX");
+    ImGui::TableNextColumn();
+    right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%s", "RX");
+
     for (auto& iface : HUDElements.net->interfaces){
         ImGui::TableNextRow();
         ImGui::TableNextColumn();
-        HUDElements.TextColored(HUDElements.colors.network, "%.8s", iface.name.c_str());
+        HUDElements.TextColored(HUDElements.colors.network, "%s", iface.name.c_str());
         ImGui::TableNextColumn();
         right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%.0f", iface.txBps / 1000.f);
         ImGui::SameLine(0,1.0f);
         ImGui::PushFont(HUDElements.sw_stats->font1);
-        HUDElements.TextColored(HUDElements.colors.text, "KB/s %s", ICON_FK_ARROW_UP);
+        HUDElements.TextColored(HUDElements.colors.text, "KB/s");
         ImGui::PopFont();
         ImGui::TableNextColumn();
         right_aligned_text(HUDElements.colors.text, HUDElements.ralign_width, "%.0f", iface.rxBps / 1000.f);
         ImGui::SameLine(0,1.0f);
         ImGui::PushFont(HUDElements.sw_stats->font1);
-        HUDElements.TextColored(HUDElements.colors.text, "KB/s %s", ICON_FK_ARROW_DOWN);
+        HUDElements.TextColored(HUDElements.colors.text, "KB/s");
         ImGui::PopFont();
     }
 #endif
@@ -1585,8 +1589,6 @@ void HudElements::legacy_elements(){
         ordered_functions.push_back({vram, "vram", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_ram])
         ordered_functions.push_back({ram, "ram", value});
-    if (!params->network.empty())
-        ordered_functions.push_back({network, "network", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_battery])
         ordered_functions.push_back({battery, "battery", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_fan])
@@ -1595,6 +1597,8 @@ void HudElements::legacy_elements(){
         ordered_functions.push_back({gamescope_fsr, "gamescope_fsr", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_hdr])
         ordered_functions.push_back({hdr, "hdr", value});
+    if (params->enabled[OVERLAY_PARAM_ENABLED_refresh_rate])
+        ordered_functions.push_back({refresh_rate, "refresh_rate", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_throttling_status])
         ordered_functions.push_back({throttling_status, "throttling_status", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_fps])
@@ -1648,12 +1652,13 @@ void HudElements::legacy_elements(){
         ordered_functions.push_back({winesync, "winesync", value});
     if (params->enabled[OVERLAY_PARAM_ENABLED_present_mode])
         ordered_functions.push_back({present_mode, "present_mode", value});
-    if (params->enabled[OVERLAY_PARAM_ENABLED_refresh_rate])
-        ordered_functions.push_back({refresh_rate, "refresh_rate", value});
+    if (!params->network.empty())
+        ordered_functions.push_back({network, "network", value});
+
 }
 
 void HudElements::update_exec(){
-#ifdef __linux__
+#ifdef __LINUX__
     if (!HUDElements.shell)
         HUDElements.shell = std::make_unique<Shell>();
 

src/hud_elements.h

@@ -54,7 +54,7 @@ class HudElements{
         int refresh = 0;
         std::unique_ptr<WineSync> winesync_ptr = nullptr;
         std::unique_ptr<Net> net = nullptr;
-#ifdef __linux__
+#ifdef __LINUX__
         std::unique_ptr<Shell> shell = nullptr;
 #endif
 

src/intel.cpp

@@ -62,6 +62,8 @@ void Intel::intel_gpu_thread(){
         if (exitcode == 1)
         SPDLOG_INFO("Missing permissions for '{}'", "intel_gpu_top");
 
+        SPDLOG_INFO("Disabling gpu_stats");
+        HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_gpu_stats] = false;
     }
 }
 
@@ -99,6 +101,7 @@ FILE* Intel::find_fd() {
                 if (found_driver){
                     if(strstr(line, "drm-engine-render")){
                         sscanf(line, "drm-engine-render: %" SCNu64 " ns", &val);
+                        if (val > 0)
                             return file;
                     }
                 }

src/intel.h

@@ -32,7 +32,7 @@ class Intel {
                 runtime = true;
 
             fdinfo = find_fd();
-            // thread = std::thread(&Intel::intel_gpu_thread, this);
+            thread = std::thread(&Intel::intel_gpu_thread, this);
         }
 
         void update() {
@@ -42,10 +42,10 @@ class Intel {
             gpu_info = gpu_info_intel;
         }
 
-        // ~Intel(){
-        //     stop = true;
-        //     thread.join();
-        // }
+        ~Intel(){
+            stop = true;
+            thread.join();
+        }
 };
 
 extern std::unique_ptr<Intel> intel;

src/logging.cpp

@@ -1,7 +1,6 @@
 #include <sstream>
 #include <iomanip>
 #include <array>
-#include <algorithm>
 #include <spdlog/spdlog.h>
 #include "logging.h"
 #include "overlay.h"
@@ -72,24 +71,12 @@ static void writeSummary(string filename){
   SPDLOG_DEBUG("Writing summary log file [{}]", filename);
   std::ofstream out(filename, ios::out | ios::app);
   if (out){
-    out << "0.1% Min FPS," << "1% Min FPS," << "97% Percentile FPS," << "Average FPS," << "GPU Load," << "CPU Load," << "Average Frame Time," << "Average GPU Temp," << "Average CPU Temp," << "Average VRAM Used," << "Average RAM Used," << "Average Swap Used," << "Peak GPU Load," << "Peak CPU Load," << "Peak GPU Temp," << "Peak CPU Temp," << "Peak VRAM Used," << "Peak RAM Used," << "Peak Swap Used" << "\n";
+    out << "0.1% Min FPS," << "1% Min FPS," << "97% Percentile FPS," << "Average FPS," << "GPU Load," << "CPU Load" << "\n";
     std::vector<logData> sorted = logArray;
     std::sort(sorted.begin(), sorted.end(), compareByFps);
     float total = 0.0f;
-    float total_gpu = 0.0f;
     float total_cpu = 0.0f;
-    int total_gpu_temp = 0.0f;
-    int total_cpu_temp = 0.0f;
-    float total_vram = 0.0f;
-    float total_ram = 0.0f;
-    float total_swap = 0.0f;
-    int peak_gpu = 0.0f;
-    float peak_cpu = 0.0f;
-    int peak_gpu_temp = 0.0f;
-    int peak_cpu_temp = 0.0f;
-    float peak_vram = 0.0f;
-    float peak_ram = 0.0f;
-    float peak_swap = 0.0f;
+    float total_gpu = 0.0f;
     float result;
     float percents[2] = {0.001, 0.01};
     for (auto percent : percents){
@@ -104,66 +91,21 @@ static void writeSummary(string filename){
     // 97th percentile
     result = sorted.empty() ? 0.0f : 1000 / sorted[floor(0.97 * (sorted.size() - 1))].frametime;
     out << fixed << setprecision(1) << result << ",";
-    // avg + peak
+    // avg
     total = 0;
     for (auto input : sorted){
       total = total + input.frametime;
-      total_gpu = total_gpu + input.gpu_load;
       total_cpu = total_cpu + input.cpu_load;
-      total_gpu_temp = total_gpu_temp + input.gpu_temp;
-      total_cpu_temp = total_cpu_temp + input.cpu_temp;
-      total_vram = total_vram + input.gpu_vram_used;
-      total_ram = total_ram + input.ram_used;
-      total_swap = total_swap + input.swap_used;
-      peak_gpu = std::max(peak_gpu, input.gpu_load);
-      peak_cpu = std::max(peak_cpu, input.cpu_load);
-      peak_gpu_temp = std::max(peak_gpu_temp, input.gpu_temp);
-      peak_cpu_temp = std::max(peak_cpu_temp, input.cpu_temp);
-      peak_vram = std::max(peak_vram, input.gpu_vram_used);
-      peak_ram = std::max(peak_ram, input.ram_used);
-      peak_swap = std::max(peak_swap, input.swap_used);
+      total_gpu = total_gpu + input.gpu_load;
     }
-    // Average FPS
     result = 1000 / (total / sorted.size());
     out << fixed << setprecision(1) << result << ",";
-    // GPU Load (Average)
+    // GPU
     result = total_gpu / sorted.size();
     out << result << ",";
-    // CPU Load (Average)
+    // CPU
     result = total_cpu / sorted.size();
-    out << result << ",";
-    // Average Frame Time
-    result = total / sorted.size();
-    out << result << ",";
-    // Average GPU Temp
-    result = total_gpu_temp / sorted.size();
-    out << result << ",";
-    // Average CPU Temp
-    result = total_cpu_temp / sorted.size();
-    out << result << ",";
-    // Average VRAM Used
-    result = total_vram / sorted.size();
-    out << result << ",";
-    // Average RAM Used
-    result = total_ram / sorted.size();
-    out << result << ",";
-    // Average Swap Used
-    result = total_swap / sorted.size();
-    out << result << ",";
-    // Peak GPU Load
-    out << peak_gpu << ",";
-    // Peak CPU Load
-    out << peak_cpu << ",";
-    // Peak GPU Temp
-    out << peak_gpu_temp << ",";
-    // Peak CPU Temp
-    out << peak_cpu_temp << ",";
-    // Peak VRAM Used
-    out << peak_vram << ",";
-    // Peak RAM Used
-    out << peak_ram << ",";
-    // Peak Swap Used
-    out << peak_swap;
+    out << result;
   } else {
     SPDLOG_ERROR("Failed to write log file");
   }
@@ -364,9 +306,6 @@ void Logger::calculate_benchmark_data(){
   string label;
   float mins[2] = {0.01f, 0.001f};
   for (auto percent : mins){
-    if (sorted.empty())
-      continue;
-
     size_t percentile_pos = sorted.size() * percent;
     percentile_pos = std::min(percentile_pos, sorted.size() - 1);
     float result = 1000 / sorted[percentile_pos];

src/meson.build

@@ -145,12 +145,12 @@ if is_unixy
       'loaders/loader_x11.cpp',
       'shared_x11.cpp',
     )
-  endif
 
     opengl_files += files(
       'loaders/loader_glx.cpp',
       'gl/inject_glx.cpp',
     )
+  endif
 
   if get_option('with_wayland').enabled()
     pre_args += '-DHAVE_WAYLAND'
@@ -278,9 +278,6 @@ if is_unixy
 endif
 
 if get_option('mangoapp')
-  if not get_option('with_x11').enabled()
-    error('mangoapp also needs \'with_x11\'')
-  endif
   pre_args += '-DIMGUI_IMPL_OPENGL_LOADER_GLEW'
   pre_args += '-DMANGOAPP'
   mangoapp = executable(

src/nvml.cpp

@@ -5,7 +5,6 @@
 #include "overlay.h"
 #include "overlay_params.h"
 #include "nvctrl.h"
-#include "logging.h"
 
 nvmlReturn_t result;
 nvmlDevice_t nvidiaDevice;
@@ -53,22 +52,16 @@ bool getNVMLInfo(const struct overlay_params& params){
     nvmlReturn_t response;
     auto& nvml = get_libnvml_loader();
     response = nvml.nvmlDeviceGetUtilizationRates(nvidiaDevice, &nvidiaUtilization);
-    if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_temp] || logger->is_active())
-        nvml.nvmlDeviceGetTemperature(nvidiaDevice, NVML_TEMPERATURE_GPU, &nvidiaTemp);
-    if (params.enabled[OVERLAY_PARAM_ENABLED_vram] || logger->is_active())
-        nvml.nvmlDeviceGetMemoryInfo(nvidiaDevice, &nvidiaMemory);
-    if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_core_clock] || logger->is_active())
-        nvml.nvmlDeviceGetClockInfo(nvidiaDevice, NVML_CLOCK_GRAPHICS, &nvidiaCoreClock);
-    if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_mem_clock] || logger->is_active())
-        nvml.nvmlDeviceGetClockInfo(nvidiaDevice, NVML_CLOCK_MEM, &nvidiaMemClock);
-    if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_power] || logger->is_active())
-        nvml.nvmlDeviceGetPowerUsage(nvidiaDevice, &nvidiaPowerUsage);
+    nvml.nvmlDeviceGetTemperature(nvidiaDevice, NVML_TEMPERATURE_GPU, &nvidiaTemp);
+    nvml.nvmlDeviceGetMemoryInfo(nvidiaDevice, &nvidiaMemory);
+    nvml.nvmlDeviceGetClockInfo(nvidiaDevice, NVML_CLOCK_GRAPHICS, &nvidiaCoreClock);
+    nvml.nvmlDeviceGetClockInfo(nvidiaDevice, NVML_CLOCK_MEM, &nvidiaMemClock);
+    nvml.nvmlDeviceGetPowerUsage(nvidiaDevice, &nvidiaPowerUsage);
     deviceID = nvidiaPciInfo.pciDeviceId >> 16;
     if (params.enabled[OVERLAY_PARAM_ENABLED_throttling_status])
         nvml.nvmlDeviceGetCurrentClocksThrottleReasons(nvidiaDevice, &nvml_throttle_reasons);
 
-    if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_fan] || logger->is_active())
-        nvml.nvmlDeviceGetFanSpeed(nvidiaDevice, &nvidiaFanSpeed);
+    nvml.nvmlDeviceGetFanSpeed(nvidiaDevice, &nvidiaFanSpeed);
 
     if (response == NVML_ERROR_NOT_SUPPORTED) {
         if (nvmlSuccess)

src/overlay.cpp

@@ -666,10 +666,6 @@ void horizontal_separator(struct overlay_params& params) {
 
 void render_imgui(swapchain_stats& data, struct overlay_params& params, ImVec2& window_size, bool is_vulkan)
 {
-   {
-      std::unique_lock<std::mutex> lock(config_mtx);
-      config_cv.wait(lock, []{ return config_ready; });
-   }
    // data.engine = EngineTypes::GAMESCOPE;
    HUDElements.sw_stats = &data; HUDElements.params = &params;
    HUDElements.is_vulkan = is_vulkan;

src/overlay_params.cpp

@@ -41,9 +41,6 @@
 #include "fps_metrics.h"
 
 std::unique_ptr<fpsMetrics> fpsmetrics;
-std::mutex config_mtx;
-std::condition_variable config_cv;
-bool config_ready = false;
 
 #if __cplusplus >= 201703L
 
@@ -111,8 +108,8 @@ parse_control(const char *str)
 
    int ret = os_socket_listen_abstract(path.c_str(), 1);
    if (ret < 0) {
-      SPDLOG_DEBUG("Couldn't create socket pipe at '{}'", path);
-      SPDLOG_DEBUG("ERROR: '{}'", strerror(errno));
+      SPDLOG_ERROR("Couldn't create socket pipe at '{}'", path);
+      SPDLOG_ERROR("ERROR: '{}'", strerror(errno));
       return ret;
    }
 
@@ -623,7 +620,6 @@ set_parameters_from_options(struct overlay_params *params)
       params->enabled[OVERLAY_PARAM_ENABLED_duration] = false;
       params->enabled[OVERLAY_PARAM_ENABLED_core_bars] = false;
       params->enabled[OVERLAY_PARAM_ENABLED_read_cfg] = read_cfg;
-      params->enabled[OVERLAY_PARAM_ENABLED_time_no_label] = false;
       params->options.erase("full");
    }
    for (auto& it : params->options) {
@@ -665,11 +661,11 @@ parse_overlay_env(struct overlay_params *params,
             add_to_options(params, key, value);
             initialize_preset(params);
          }
+         presets(current_preset, params);
          break;
       }
    }
 
-   presets(current_preset, params);
    env = env_start;
 
    while ((num = parse_string(env, key, value)) != 0) {
@@ -758,7 +754,7 @@ static void set_param_defaults(struct overlay_params *params){
    params->background_color = 0x020202;
    params->text_color = 0xffffff;
    params->media_player_color = 0xffffff;
-   params->network_color = 0xe07b85;
+   params->network_color = 0xd66077;
    params->media_player_name = "";
    params->font_scale = 1.0f;
    params->wine_color = 0xeb5b5b;
@@ -794,9 +790,6 @@ parse_overlay_config(struct overlay_params *params,
      .preset = use_existing_preset ? params->preset : default_preset
    };
    set_param_defaults(params);
-   if (!use_existing_preset) {
-      current_preset = params->preset[0];
-   }
 
 #ifdef HAVE_X11
    params->toggle_hud = { XK_Shift_R, XK_F12 };
@@ -860,10 +853,10 @@ parse_overlay_config(struct overlay_params *params,
       set_parameters_from_options(params);
    }
 
-   if (params->enabled[OVERLAY_PARAM_ENABLED_legacy_layout])
-      HUDElements.ordered_functions.clear();
-
-   if (env && read_cfg) {
+   // TODO decide what to do for legacy_layout=0
+   // second pass, override config file settings with MANGOHUD_CONFIG
+   if (params->enabled[OVERLAY_PARAM_ENABLED_legacy_layout] && env && read_cfg) {
+      // If passing legacy_layout=0 to MANGOHUD_CONFIG anyway then clear first pass' results
       HUDElements.ordered_functions.clear();
       parse_overlay_env(params, env, true);
    }
@@ -979,7 +972,6 @@ parse_overlay_config(struct overlay_params *params,
    if (params->enabled[OVERLAY_PARAM_ENABLED_legacy_layout]) {
       HUDElements.legacy_elements();
    } else {
-      HUDElements.ordered_functions.clear();
       for (auto& option : HUDElements.options) {
          HUDElements.sort_elements(option);
       }
@@ -1009,12 +1001,6 @@ parse_overlay_config(struct overlay_params *params,
 #endif
    if (HUDElements.net)
       HUDElements.net->should_reset = true;
-
-   {
-      std::lock_guard<std::mutex> lock(config_mtx);
-      config_ready = true;
-      config_cv.notify_one();
-   }
 }
 
 bool parse_preset_config(int preset, struct overlay_params *params){
@@ -1029,7 +1015,7 @@ bool parse_preset_config(int preset, struct overlay_params *params){
    stream.imbue(std::locale::classic());
 
    if (!stream.good()) {
-      SPDLOG_DEBUG("Failed to read presets file: '{}'.  Falling back to default presets", preset_path);
+      SPDLOG_ERROR("Failed to read presets file: '{}'", preset_path);
       return false;
    }
 
@@ -1147,11 +1133,6 @@ void presets(int preset, struct overlay_params *params, bool inherit) {
          add_to_options(params, "debug", "1");
          add_to_options(params, "version", "0");
          add_to_options(params, "frame_timing_detailed", "1");
-         add_to_options(params, "network", "1");
-         add_to_options(params, "present_mode", "0");
-         if ( deviceID == 0x1435 || deviceID == 0x163f )
-            add_to_options(params, "gpu_fan", "0");
-
          break;
 
    }

src/overlay_params.h

@@ -6,8 +6,6 @@
 #include <vector>
 #include <unordered_map>
 #include <cstdint>
-#include <condition_variable>
-#include <mutex>
 
 #ifdef __cplusplus
 extern "C" {
@@ -332,11 +330,9 @@ void parse_overlay_config(struct overlay_params *params,
 void presets(int preset, struct overlay_params *params, bool inherit=false);
 bool parse_preset_config(int preset, struct overlay_params *params);
 void add_to_options(struct overlay_params *params, std::string option, std::string value);
+
 #ifdef __cplusplus
 }
 #endif
-extern std::mutex config_mtx;
-extern std::condition_variable config_cv;
-extern bool config_ready;
 
 #endif /* MANGOHUD_OVERLAY_PARAMS_H */

src/shared_x11.cpp

@@ -35,11 +35,8 @@ bool init_x11() {
     }
 
     failed = !display;
-    if (failed && displayid)
+    if (failed)
         SPDLOG_ERROR("XOpenDisplay failed to open display '{}'", displayid);
-    
-    if (!displayid)
-        SPDLOG_DEBUG("DISPLAY env is not set");
 
     return !!display;
 }

src/shell.cpp

@@ -2,49 +2,43 @@
 #include <thread>
 #include <iostream>
 #include <sys/wait.h>
-#include <spdlog/spdlog.h>
-#include "string_utils.h"
-#include <array>
 
 std::string Shell::readOutput() {
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    std::string output;
+    char buffer[256];
+    ssize_t bytesRead;
+    bool dataAvailable = false;
 
-    std::array<char, 128> buffer;
-    std::string result;
-    ssize_t count;
-    while ((count = ::read(from_shell[0], buffer.data(), buffer.size())) > 0) {
-        result.append(buffer.data(), count);
+    // Wait for up to 500 milliseconds for output to become available
+    for (int i = 0; i < 10; ++i) {
+        bytesRead = read(from_shell[0], buffer, sizeof(buffer) - 1);
+        if (bytesRead > 0) {
+            buffer[bytesRead] = '\0';
+            output += buffer;
+            dataAvailable = true;
+            break; // Break as soon as we get some data
+        } else {
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
     }
 
-    // Split the result into lines and return the last line
-    std::istringstream stream(result);
-    std::string line;
-    std::string last_line;
-    while (std::getline(stream, line)) {
-        last_line = line;
+    // If we detected data, keep reading until no more is available
+    while (dataAvailable) {
+        bytesRead = read(from_shell[0], buffer, sizeof(buffer) - 1);
+        if (bytesRead > 0) {
+            buffer[bytesRead] = '\0';
+            output += buffer;
+        } else {
+            break; // No more data available
+        }
     }
 
-    SPDLOG_DEBUG("Shell: recieved output: {}", last_line);
-    return last_line;
+    return output;
 }
 
 Shell::Shell() {
-    static bool failed;
-    if (pipe(to_shell) == -1) {
-        SPDLOG_ERROR("Failed to create to_shell pipe: {}", strerror(errno));
-        failed = true;
-    }
-
-    if (pipe(from_shell) == -1) {
-        SPDLOG_ERROR("Failed to create from_shell pipe: {}", strerror(errno));
-        failed = true;
-    }
-
-    // if either pipe fails, there's no point in continuing.
-    if (failed){
-        SPDLOG_ERROR("Shell has failed, will not be able to use exec");
-        return;
-    }
+    pipe(to_shell);
+    pipe(from_shell);
 
     shell_pid = fork();
 
@@ -64,30 +58,15 @@ Shell::Shell() {
         // Set the read end of the from_shell pipe to non-blocking
         setNonBlocking(from_shell[0]);
     }
-    success = true;
 }
 
 std::string Shell::exec(std::string cmd) {
-    if (!success)
-        return "";
-
     writeCommand(cmd);
     return readOutput();
 }
 
-void Shell::writeCommand(std::string command) {
-    std::string command_without_preload = "LD_PRELOAD= " + command;
-    
-    if (write(to_shell[1], command_without_preload.c_str(), command_without_preload.length()) == -1)
-        SPDLOG_ERROR("Failed to write to shell");
-    
-    trim(command);
-    SPDLOG_DEBUG("Shell: wrote command: {}", command);
-}
-
 Shell::~Shell() {
-    if (write(to_shell[1], "exit\n", 5) == -1)
-        SPDLOG_ERROR("Failed exit shell");
+    write(to_shell[1], "exit\n", 5);
     close(to_shell[1]);
     close(from_shell[0]);
     waitpid(shell_pid, nullptr, 0);

src/shell.h

@@ -13,7 +13,6 @@ private:
     int to_shell[2];
     int from_shell[2];
     pid_t shell_pid;
-    bool success;
 
 #ifdef __linux__
     void setNonBlocking(int fd) {
@@ -22,7 +21,10 @@ private:
     }
 #endif
 
-    void writeCommand(std::string command);
+    void writeCommand(const std::string& command) {
+        write(to_shell[1], command.c_str(), command.length());
+    }
+
     std::string readOutput();
 
 public:

subprojects/spdlog.wrap

@@ -1,13 +1,13 @@
 [wrap-file]
-directory = spdlog-1.14.1
-source_url = https://github.com/gabime/spdlog/archive/refs/tags/v1.14.1.tar.gz
-source_filename = spdlog-1.14.1.tar.gz
-source_hash = 1586508029a7d0670dfcb2d97575dcdc242d3868a259742b69f100801ab4e16b
-patch_filename = spdlog_1.14.1-1_patch.zip
-patch_url = https://wrapdb.mesonbuild.com/v2/spdlog_1.14.1-1/get_patch
-patch_hash = ae878e732330ea1048f90d7e117c40c0cd2a6fb8ae5492c7955818ce3aaade6c
-source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/spdlog_1.14.1-1/spdlog-1.14.1.tar.gz
-wrapdb_version = 1.14.1-1
+directory = spdlog-1.13.0
+source_url = https://github.com/gabime/spdlog/archive/refs/tags/v1.13.0.tar.gz
+source_filename = spdlog-1.13.0.tar.gz
+source_hash = 534f2ee1a4dcbeb22249856edfb2be76a1cf4f708a20b0ac2ed090ee24cfdbc9
+patch_filename = spdlog_1.13.0-1_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/spdlog_1.13.0-1/get_patch
+patch_hash = 556b539cf582a46673ede4202ac037b891328dd5ea76862ffe05b060fc4f4775
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/spdlog_1.13.0-1/spdlog-1.13.0.tar.gz
+wrapdb_version = 1.13.0-1
 
 [provide]
 spdlog = spdlog_dep