Param: dx_api

This option tries to figure out the underlying DirectX
API being used for the application

Author: flightlessmango

src/engine_types.h

@@ -811,20 +811,7 @@ void HudElements::procmem()
 void HudElements::fps(){
     if (HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_fps] && !HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_fps_only]){
         ImguiNextColumnFirstItem();
-        if (HUDElements.params->fps_text.empty()){
-            if(HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_engine_short_names])
-                if(HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_hide_engine_names])
-                    HUDElements.TextColored(HUDElements.colors.engine, "%s", "FPS");
-                else
-                    HUDElements.TextColored(HUDElements.colors.engine, "%s", engines_short[HUDElements.sw_stats->engine]);
-            else
-                if(HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_hide_engine_names])
-                    HUDElements.TextColored(HUDElements.colors.engine, "%s", "FPS");
-                else
-                    HUDElements.TextColored(HUDElements.colors.engine, "%s", engines[HUDElements.sw_stats->engine]);
-        } else {
-            HUDElements.TextColored(HUDElements.colors.engine, "%s", HUDElements.params->fps_text.c_str());
-        }
+        HUDElements.TextColored(HUDElements.colors.engine, "%s", engine_name(*HUDElements.sw_stats));
 
         ImguiNextColumnOrNewRow();
         if (HUDElements.params->enabled[OVERLAY_PARAM_ENABLED_fps_color_change]){

src/hud_elements.cpp

@@ -45,8 +45,6 @@ struct benchmark_stats benchmark;
 struct fps_limit fps_limit_stats {};
 ImVec2 real_font_size;
 std::deque<logData> graph_data;
-const char* engines[] = {"Unknown", "OpenGL", "VULKAN", "DXVK", "VKD3D", "DAMAVAND", "ZINK", "WINED3D", "Feral3D", "ToGL", "GAMESCOPE"};
-const char* engines_short[] = {"Unknown", "OGL", "VK", "DXVK", "VKD3D", "DV", "ZINK", "WD3D", "Feral3D", "ToGL", "GS"};
 overlay_params *_params {};
 double min_frametime, max_frametime;
 bool gpu_metrics_exists = false;

src/overlay.cpp

@@ -10,7 +10,6 @@
 #include "imgui_internal.h"
 #include "overlay_params.h"
 #include "hud_elements.h"
-#include "engine_types.h"
 
 #include "dbus_info.h"
 #include "logging.h"
@@ -21,6 +20,25 @@ struct frame_stat {
 
 static const int kMaxGraphEntries = 50;
 
+enum EngineTypes
+{
+   UNKNOWN,
+
+   OPENGL,
+   VULKAN,
+
+   DXVK,
+   VKD3D,
+   DAMAVAND,
+   ZINK,
+
+   WINED3D,
+   FERAL3D,
+   TOGL,
+
+   GAMESCOPE
+};
+
 struct swapchain_stats {
    uint64_t n_frames;
    enum overlay_plots stat_selector;
@@ -38,7 +56,7 @@ struct swapchain_stats {
    unsigned n_frames_since_update;
    uint64_t last_fps_update;
    ImVec2 main_window_pos;
-
+   
    struct {
       int32_t major;
       int32_t minor;
@@ -54,6 +72,7 @@ struct swapchain_stats {
    std::string deviceName;
    std::string gpuName;
    std::string driverName;
+   uint32_t applicationVersion;
    enum EngineTypes engine;
 };
 
@@ -80,6 +99,39 @@ struct LOAD_DATA {
    unsigned high_load;
 };
 
+
+inline const char* engine_name(struct swapchain_stats& sw_stats) {
+   const char* engines[] = {"Unknown", "OpenGL", "VULKAN", "DXVK", "VKD3D", "DAMAVAND", "ZINK", "WINED3D", "Feral3D", "ToGL", "GAMESCOPE"};
+   const char* engines_short[] = {"Unknown", "OGL", "VK", "DXVK", "VKD3D", "DV", "ZINK", "WD3D", "Feral3D", "ToGL", "GS"};
+   auto engine = sw_stats.engine;
+   auto params = get_params();
+   auto& enabled = params->enabled;
+
+   // if fps_text is set, we ignore all other options
+   if (!params->fps_text.empty())
+      return params->fps_text.c_str();
+
+    const bool is_compact =
+        enabled[OVERLAY_PARAM_ENABLED_hud_compact] ||
+        enabled[OVERLAY_PARAM_ENABLED_horizontal];
+
+    const bool short_pref = enabled[OVERLAY_PARAM_ENABLED_engine_short_names];
+
+    if (is_compact && !short_pref)
+        return "FPS";
+
+    if (enabled[OVERLAY_PARAM_ENABLED_dx_api]) {
+        if (engine == EngineTypes::VKD3D) return "DX12";
+        if (engine == EngineTypes::DXVK) {
+            if (sw_stats.applicationVersion == 1) return "DX9";
+            if (sw_stats.applicationVersion == 2) return "DX11";
+            return "DX?";
+        }
+    }
+
+    return short_pref || is_compact ? engines_short[engine] : engines[engine];
+}
+
 extern struct fps_limit fps_limit_stats;
 extern uint32_t deviceID;
 

src/overlay.h

@@ -129,6 +129,7 @@ struct Tracepoint;
    OVERLAY_PARAM_BOOL(gpu_efficiency)                \
    OVERLAY_PARAM_BOOL(flip_efficiency)               \
    OVERLAY_PARAM_BOOL(gpu_power_limit)               \
+   OVERLAY_PARAM_BOOL(dx_api)                        \
    OVERLAY_PARAM_CUSTOM(fps_sampling_period)         \
    OVERLAY_PARAM_CUSTOM(output_folder)               \
    OVERLAY_PARAM_CUSTOM(output_file)                 \

src/overlay_params.h

@@ -82,6 +82,7 @@ struct instance_data {
    enum EngineTypes engine;
    notify_thread notifier;
    int control_client;
+   uint32_t applicationVersion;
 };
 
 /* Mapped from VkDevice */
@@ -1582,6 +1583,7 @@ static VkResult overlay_CreateSwapchainKHR(
    swapchain_data->sw_stats.engineName    = device_data->instance->engineName;
    swapchain_data->sw_stats.engineVersion = device_data->instance->engineVersion;
    swapchain_data->sw_stats.engine        = device_data->instance->engine;
+   swapchain_data->sw_stats.applicationVersion = device_data->instance->applicationVersion;
 
    HUDElements.vendorID = prop.vendorID;
    std::stringstream ss;
@@ -1904,8 +1906,12 @@ static VkResult overlay_CreateInstance(
    std::string engineVersion, engineName;
    enum EngineTypes engine = EngineTypes::UNKNOWN;
    const char* pEngineName = nullptr;
-   if (pCreateInfo->pApplicationInfo)
+
+   struct instance_data *instance_data = new_instance_data(*pInstance); 
+   if (pCreateInfo->pApplicationInfo) {
       pEngineName = pCreateInfo->pApplicationInfo->pEngineName;
+      instance_data->applicationVersion = pCreateInfo->pApplicationInfo->applicationVersion;
+   }
    if (pEngineName)
    {
       engineName = pEngineName;
@@ -1953,7 +1959,6 @@ static VkResult overlay_CreateInstance(
    VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
    if (result != VK_SUCCESS) return result;
 
-   struct instance_data *instance_data = new_instance_data(*pInstance);
    vk_load_instance_commands(instance_data->instance,
                              fpGetInstanceProcAddr,
                              &instance_data->vtable);