Add profiling to application

Author: Crementif

README.md

@@ -75,7 +75,9 @@ While more integrated solutions are being found out, there's probably ways to se
    - `FPS++`: Set the FPS limit to at least 120 or 144. Your headset/runtime will still control the actual VR framerate.
    - `Enhancements`: Set anisotropic filtering to 16x, and optionally set a Clarity preset to make the colors less washed out.
 
-7. Double click the game in Cemu's game list while your VR headset is turned on and connected. If things went correctly, you should now be playing the game in VR!  
+7. [Optional] To avoid some heavy stutters when you first start the game, download the shader caches from https://chriztr.github.io/cemu_shader_and_pipeline_caches/ and follow the `How to install the caches` section on that page.
+
+8. Double click the game in Cemu's game list while your VR headset is turned on and connected. If things went correctly, you should now be playing the game in VR!  
 
 Use the in-game BetterVR menu to see the BetterVR settings and controls guide (hold the X or equivalent button on your left VR controller, or long press the Menu button on your Xbox controller).  
 In the settings you can also enable an option to immediately start the game when you start the `BetterVR_Launcher.exe`. You can also add this executable to Virtual Desktop, SteamVR etc. as a non-official Steam game.

include/pch.h

@@ -63,6 +63,7 @@ using Microsoft::WRL::ComPtr;
 #include <imgui.h>
 #include <imgui_impl_vulkan.h>
 #include <implot.h>
+#include <imgui_memory_editor.h>
 
 // glm includes
 #define GLM_FORCE_XYZW_ONLY
@@ -533,3 +534,4 @@ struct data_VRProjectionMatrixOut {
 #include "game_structs.h"
 #include "cemu.h"
 #include "utils/logger.h"
+#include "utils/profiler.h"

src/CMakeLists.txt

@@ -17,6 +17,7 @@ target_sources(BetterVR_Layer PUBLIC
     ${CMAKE_SOURCE_DIR}/src/utils/logger.cpp
     ${CMAKE_SOURCE_DIR}/src/utils/logger.h
     ${CMAKE_SOURCE_DIR}/src/utils/mod_settings.h
+    ${CMAKE_SOURCE_DIR}/src/utils/profiler.h
     ${CMAKE_SOURCE_DIR}/src/utils/debug_draw.h
     ${CMAKE_SOURCE_DIR}/src/utils/debug_draw.cpp
     ${CMAKE_SOURCE_DIR}/src/hooking/framebuffer.cpp

src/hooking/entity_controller.cpp

@@ -497,6 +497,8 @@ static glm::fmat3 GetRoomscaleWorldToRoomRotation() {
 }
 
 static void ClearRoomscaleResolveState() {
+    BetterVRProfiler::EndSpan(BetterVRProfiler::Section::RoomscaleResolve);
+
     s_roomscaleState.isResolving = false;
     s_roomscaleState.isProbeOnly = false;
     s_roomscaleState.remainingRawDelta = glm::fvec3(0.0f);
@@ -755,6 +757,8 @@ float CemuHooks::GetRoomscaleFadeAmount() {
 
 
 void CemuHooks::hook_BeginRoomscaleMovement(PPCInterpreter_t* hCPU) {
+    BetterVRProfiler::Scope profile(BetterVRProfiler::Section::RoomscaleBeginHook);
+
     hCPU->instructionPointer = hCPU->sprNew.LR;
 
     uint32_t controller = hCPU->gpr[3];
@@ -793,6 +797,7 @@ void CemuHooks::hook_BeginRoomscaleMovement(PPCInterpreter_t* hCPU) {
         s_roomscaleState.isResolving = true;
         s_roomscaleState.isProbeOnly = true;
         hCPU->gpr[3] = RoomscaleHookResult_Cast;
+        BetterVRProfiler::BeginSpan(BetterVRProfiler::Section::RoomscaleResolve);
         return;
     }
     (void)currentHeadPos;
@@ -807,6 +812,7 @@ void CemuHooks::hook_BeginRoomscaleMovement(PPCInterpreter_t* hCPU) {
     s_roomscaleState.isResolving = true;
     s_roomscaleState.isProbeOnly = false;
     hCPU->gpr[3] = RoomscaleHookResult_Cast;
+    BetterVRProfiler::BeginSpan(BetterVRProfiler::Section::RoomscaleResolve);
 }
 
 void CemuHooks::hook_PrepareRoomscaleRaycast(PPCInterpreter_t* hCPU) {

src/hooking/entity_debugger.cpp

@@ -1,11 +1,8 @@
 #include "pch.h"
 #include "entity_debugger.h"
 #include "instance.h"
-#include "rendering/vulkan.h"
 #include "utils/mod_settings.h"
 
-#include <imgui_memory_editor.h>
-
 #include "utils/debug_draw.h"
 
 std::mutex g_actorListMutex;
@@ -65,7 +62,6 @@ void CemuHooks::hook_UpdateActorList(PPCInterpreter_t* hCPU) {
          s_cameraMtxAddress = actorMtxPtr;
      }
 }
-
 // ksys::phys::RigidBodyFromShape::create to create a RigidBody from a shape
 // use Actor::getRigidBodyByName
 
@@ -483,8 +479,6 @@ void EntityDebugger::RemoveEntityValue(uint32_t actorId, const std::string& valu
         }).begin(), it->second.values.end());
     }
 }
-
-
 std::array<bool, 256> s_pressedKeyState = {};
 std::array<bool, ImGuiKey_NamedKey_COUNT> s_pressedNamedKeyState = {};
 
@@ -575,143 +569,3 @@ void EntityDebugger::UpdateKeyboardControls() {
         ImGui::GetIO().AddKeyEvent(ImGuiKey_Backspace, false);
     }
 }
-
-
-void EntityDebugger::DrawFPSOverlay(RND_Renderer* renderer) {
-    ImGui::SetNextWindowBgAlpha(0.4f);
-
-    ImVec2 windowSize = ImGui::GetIO().DisplaySize;
-
-    const ImVec2 pad(10.0f, 10.0f);
-    ImGui::SetNextWindowPos(ImVec2(windowSize.x - pad.x, pad.y), ImGuiCond_Always, ImVec2(1.0f, 0.0f));
-
-    if (ImGui::Begin("AppMS Overlay", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove)) {
-        DrawFPSOverlayContent(renderer, false);
-    }
-    ImGui::End();
-}
-
-void EntityDebugger::DrawFPSOverlayContent(RND_Renderer* renderer, bool renderText) {
-    const float predictedDisplayPeriodMs = (float)renderer->GetPredictedDisplayPeriodMs();
-    const float predictedHz = GetSettings().performanceOverlayFrequency;
-
-    const float appMs = (float)renderer->GetLastFrameTimeMs();      // Total frame time (includes wait)
-    const float workMs = (float)renderer->GetLastFrameWorkTimeMs(); // GPU Work time only (excludes wait)
-    const float waitMs = (float)renderer->GetLastWaitTimeMs();
-    const float overheadMs = (float)renderer->GetLastOverheadMs();
-
-    // --- 2. Convert to FPS ---
-    const float appFps = appMs > 0.0000001f ? (1000.0f / appMs) : 0.0f;
-
-    // "Theoretical FPS": How fast you COULD run if you didn't have to wait for V-Sync/OpenXR
-    const float workFps = workMs >= 0.0000001f ? (1000.0f / workMs) : 0.0f;
-
-    // Calculate percentage of the frame budget used (still useful in % terms)
-    const float workPct = predictedDisplayPeriodMs > 0.0f ? (workMs / predictedDisplayPeriodMs) * 100.0f : 0.0f;
-
-    // --- 3. Text Summary ---
-    if (renderText) {
-        ImGui::Text("The visualization refresh rate of your headset is set to %.0f Hz", predictedHz);
-        ImGui::Text("Currently Running At %.1f FPS", appFps);
-        ImGui::Text("");
-        ImGui::Text("OpenXR waited %.1f ms so that it can interpolate/have low latency.", waitMs);
-        ImGui::Text("Theoretically, it'd run at %.1f FPS if that didn't matter", workFps);
-    }
-
-    if (predictedHz > 0.0f && workFps >= 0.0f) {
-        auto rateForDivisor = [predictedHz](int divisor) -> double {
-            return divisor > 0 ? (predictedHz / (double)divisor) : 0.0;
-        };
-
-        auto chooseBestDivisor = [&](double fps) -> int {
-            // Pick the refresh divisor (1x, 1/2x, 1/3x, 1/4x) that is able to be achieved using the workFPS (frame time minus OpenXR wait time)
-            for (int div = 1; div <= 4; ++div) {
-                if (fps >= rateForDivisor(div)) {
-                    return div;
-                }
-            }
-            return 4;
-        };
-
-        // Use theoretical FPS (GPU work time) as the basis for which step we're closest to.
-        const int currentDiv = chooseBestDivisor(workFps);
-        const double currentTarget = rateForDivisor(currentDiv);
-        const int nextDiv = std::max(1, currentDiv - 1);
-        const double nextTarget = rateForDivisor(nextDiv);
-        const double missingNext = std::max(0.0, nextTarget - (double)workFps);
-
-        if (renderText) {
-            if (currentDiv == 1) {
-                ImGui::Text("Its reaching the full refresh rate you've set (%.0f hz)", currentTarget);
-                ImGui::Text("You've got ~%.1f FPS of headroom to spare", (float)std::max(0.0, (double)workFps - nextTarget));
-            }
-            else {
-                ImGui::Text("It is however able to reliably reach %.0f FPS (%.0f Hz / %d)", currentTarget, predictedHz, currentDiv);
-                ImGui::Text("You'd need to get %.1f FPS more to get it to switch to %.0f FPS", missingNext, nextTarget);
-            }
-        }
-    }
-
-    // --- 4. History Buffers (Storing FPS now) ---
-    static float history_app_fps[60] = {};
-    static float history_work_fps[60] = {};
-    static int offset = 0;
-
-    history_app_fps[offset] = appFps;
-    history_work_fps[offset] = workFps;
-    offset = (offset + 1) % 60;
-
-    // --- 5. Plotting ---
-    const double targetFps = predictedHz;
-    const double halfFps = predictedHz / 2.0;
-    const double thirdFps = predictedHz / 3.0;
-    const double fourthFps = predictedHz / 4.0;
-    
-    if (ImPlot::BeginPlot("##Frametime", ImVec2(300, 150), ImPlotFlags_NoFrame | ImPlotFlags_NoTitle | ImPlotFlags_NoMouseText | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoInputs)) {
-        ImPlot::SetupAxes(nullptr, "##FPS", ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoInitialFit);
-        ImPlot::SetupAxisLimits(ImAxis_X1, 0, 60, ImPlotCond_Always);
-
-        if (targetFps >= 0.000000001f) {
-            ImPlot::SetupAxisLimits(ImAxis_Y1, 0.0, predictedHz * 1.5f, ImPlotCond_Always);
-
-            // 1. Target Refresh Rate (Green)
-            ImPlot::SetNextLineStyle(ImVec4(0, 1, 0, 0.5f));
-            ImPlot::PlotInfLines("##Target", &targetFps, 1, ImPlotInfLinesFlags_Horizontal);
-            ImPlot::TagY(targetFps, ImVec4(0, 1, 0, 0.5f), "%.0f Hz", targetFps);
-
-            // 2. Half Rate (ASW/Reprojection threshold) (Yellow)
-            ImPlot::SetNextLineStyle(ImVec4(1, 1, 0, 0.5f));
-            ImPlot::PlotInfLines("##1/2 Rate", &halfFps, 1, ImPlotInfLinesFlags_Horizontal);
-            ImPlot::TagY(halfFps, ImVec4(1, 1, 0, 0.5f), "%.0f Hz", halfFps);
-
-            // 3. Third Rate (Red)
-            ImPlot::SetNextLineStyle(ImVec4(1, 0, 0, 0.5f));
-            ImPlot::PlotInfLines("##1/3 Rate", &thirdFps, 1, ImPlotInfLinesFlags_Horizontal);
-        }
-        else {
-            ImPlot::SetupAxisLimits(ImAxis_Y1, 0.0, 144.0, ImPlotCond_Always);
-        }
-
-        // --- Draw Graphs ---
-        // 1. Theoretical Max FPS (Work Time) - Purple/Pink
-        ImPlot::SetNextLineStyle(ImVec4(1.0f, 0.4f, 1.0f, 1.0f));
-        ImPlot::PlotLine("Theoretical Max", history_work_fps, 60, 1.0, 0.0, 0, offset);
-
-        // 2. Actual FPS (App Time) - Blue
-        // This represents what is actually hitting the screen (capped by Wait).
-        ImPlot::SetNextFillStyle(ImVec4(0.4f, 0.4f, 1.0f, 0.50f));
-        ImPlot::SetNextLineStyle(ImVec4(0.4f, 0.4f, 1.0f, 1.0f));
-        ImPlot::PlotShaded("Actual", history_app_fps, 60, 0.0, 1.0, 0.0, 0, offset);
-        ImPlot::PlotLine("##TotalLine", history_app_fps, 60, 1.0, 0.0, 0, offset);
-
-        // Current FPS Tag
-        if (appFps > 0.0f) {
-            const double currentFps = appFps;
-            ImPlot::SetNextLineStyle(ImVec4(1, 1, 1, 0.65f));
-            ImPlot::PlotInfLines("##Current", &currentFps, 1, ImPlotInfLinesFlags_Horizontal);
-            ImPlot::TagY(currentFps, ImVec4(1, 1, 1, 0.8f), "%.1f FPS", currentFps);
-        }
-
-        ImPlot::EndPlot();
-    }
-}

src/hooking/entity_debugger.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <imgui_memory_editor.h>
-
 struct MemoryRange {
     uint32_t start;
     uint32_t end;
@@ -24,8 +22,6 @@ class EntityDebugger {
     void UpdateKeyboardControls();
     void DrawWorldSpaceOverlaySettings(bool* changed);
     void DrawEntityInspectorContent();
-    static void DrawFPSOverlay(class RND_Renderer* renderer);
-    static void DrawFPSOverlayContent(class RND_Renderer* renderer, bool renderText);
 
     struct EntityValue {
         std::string value_name;