Add FPS overlay, clean-up rendering code and add meta sim fix

This does rework a lot of the AMD rendering fixes that was merged earlier, but I made sure that 3-4 people tested it to work on their AMD GPU still.

Some upcoming changes will tackle a lot of the rendering features again, so I wanted to clean up the code since it was a bit too verbose, especially regarding the image layout. For our purposes, GPU rendering isn't really ever the bottleneck, and maintainability is of high importance due to the complications with interop and being a Vulkan hook. That's why I decided on using general image layouts, which most desktop drivers seem to ignore anyway judging by the very minor to no performance uplift when applied properly, at least on main GPU vendors on desktop.

It also corrects some mistakes, such as that transitioning OpenXR's swapchains from general to present, despite them already being in that image layout according to the spec.

Author: Crementif

src/hooking/camera.cpp

@@ -561,23 +561,10 @@ void CemuHooks::hook_GetEventName(PPCInterpreter_t* hCPU) {
     hCPU->instructionPointer = hCPU->sprNew.LR;
 
     uint32_t isEventActive = hCPU->gpr[3];
-    uint32_t ppcAddress = hCPU->gpr[4];
+    uint32_t eventNamePtr = hCPU->gpr[4];
 
     if (isEventActive) {
-        // Validate PPC address is in valid game memory range
-        if (ppcAddress < 0x10000000 || ppcAddress > 0x50000000) {
-            return;
-        }
-
-        const char* eventNamePtr = (const char*)(ppcAddress + s_memoryBaseAddress);
-
-        // Validate the string starts with a printable ASCII character
-        unsigned char firstChar = static_cast<unsigned char>(eventNamePtr[0]);
-        if (firstChar < 0x20 || firstChar > 0x7E) {
-            return;
-        }
-
-        std::string eventName = std::string(eventNamePtr);
+        std::string eventName = std::string((char*)s_memoryBaseAddress + eventNamePtr);
         if (s_currentEvent == eventName) {
             return;
         }

src/hooking/framebuffer.cpp

@@ -2,7 +2,7 @@
 #include "instance.h"
 
 static XrBool32 XR_DebugUtilsMessengerCallback(XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageType, const XrDebugUtilsMessengerCallbackDataEXT* callbackData, void* userData) {
-    //Log::print("[OpenXR Debug Utils] Function {}: {}", callbackData->functionName, callbackData->message);
+    Log::print<XR_DEBUGUTILS>("[XR Debug Utils] Function {}: {}", callbackData->functionName, callbackData->message);
     return XR_FALSE;
 }
 
@@ -37,7 +37,7 @@ OpenXR::OpenXR() {
         }
         else if (strcmp(extensionProperties.extensionName, XR_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) {
 #if defined(_DEBUG)
-            debugUtilsSupported = Log::isLogTypeEnabled<VERBOSE>();
+            debugUtilsSupported = Log::isLogTypeEnabled<XR_DEBUGUTILS>();
 #endif
         }
     }
@@ -53,10 +53,8 @@ OpenXR::OpenXR() {
     if (!timeConvSupported) {
         Log::print<WARNING>("OpenXR runtime doesn't support converting time from/to XrTime (XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME). Not required, as of this version.");
     }
-    if (!debugUtilsSupported) {
-#if defined(_DEBUG)
+    if (!debugUtilsSupported && Log::isLogTypeEnabled<XR_DEBUGUTILS>()) {
         Log::print<INFO>("OpenXR runtime doesn't support debug utils (XR_EXT_DEBUG_UTILS)! Errors/debug information will no longer be able to be shown!");
-#endif
     }
 
     std::vector<const char*> enabledExtensions = { XR_KHR_D3D12_ENABLE_EXTENSION_NAME, XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME, XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME };
@@ -131,7 +129,8 @@ OpenXR::OpenXR() {
 
     m_capabilities.isOculusLinkRuntime = std::string(properties.runtimeName) == "Oculus";
     Log::print<INFO>(" - Using Meta Quest Link OpenXR runtime: {}", m_capabilities.isOculusLinkRuntime ? "Yes" : "No");
-
+    
+    m_capabilities.isMetaSimulator = std::string(properties.runtimeName).find("Meta XR Simulator") != std::string::npos;
 }
 
 OpenXR::~OpenXR() {

src/rendering/openxr.cpp

@@ -21,6 +21,7 @@ class OpenXR {
         bool supportsPositional;
         bool supportsMutatableFOV;
         bool isOculusLinkRuntime;
+        bool isMetaSimulator;
     } m_capabilities = {};
 
     union InputState {

src/rendering/openxr.h

@@ -85,6 +85,12 @@ class RND_Renderer {
         return ToMat4(middlePos, middleOri);
     };
 
+    double GetLastFrameWorkTimeMs() const { return m_lastFrameWorkTimeMs; }
+    double GetLastWaitTimeMs() const { return m_lastWaitTimeMs; }
+    double GetLastFrameTimeMs() const { return m_lastFrameTimeMs; }
+    double GetPredictedDisplayPeriodMs() const { return m_predictedDisplayPeriodMs; }
+    double GetLastOverheadMs() const { return m_lastOverheadMs; }
+
     void On3DColorCopied(OpenXR::EyeSide side, long frameIdx) {
         m_renderFrames[frameIdx].copiedColor[side] = true;
         if (!m_renderFrames[frameIdx].views.has_value()) m_renderFrames[frameIdx].views = m_currViews;
@@ -104,11 +110,11 @@ class RND_Renderer {
 
     class Layer3D {
     public:
-        explicit Layer3D(VkExtent2D extent);
+        explicit Layer3D(VkExtent2D inputRes, VkExtent2D outputRes);
         ~Layer3D();
 
-        SharedTexture* CopyColorToLayer(OpenXR::EyeSide side, VkCommandBuffer copyCmdBuffer, VkImage image, long frameIdx, VkImageLayout srcImageLayout);
-        SharedTexture* CopyDepthToLayer(OpenXR::EyeSide side, VkCommandBuffer copyCmdBuffer, VkImage image, long frameIdx, VkImageLayout srcImageLayout);
+        SharedTexture* CopyColorToLayer(OpenXR::EyeSide side, VkCommandBuffer copyCmdBuffer, VkImage image, long frameIdx);
+        SharedTexture* CopyDepthToLayer(OpenXR::EyeSide side, VkCommandBuffer copyCmdBuffer, VkImage image, long frameIdx);
         void PrepareRendering(OpenXR::EyeSide side);
         void StartRendering();
         void Render(OpenXR::EyeSide side, long frameIdx);
@@ -133,10 +139,10 @@ class RND_Renderer {
 
     class Layer2D {
     public:
-        explicit Layer2D(VkExtent2D extent);
+        explicit Layer2D(VkExtent2D inputRes, VkExtent2D outputRes);
         ~Layer2D();
 
-        SharedTexture* CopyColorToLayer(VkCommandBuffer copyCmdBuffer, VkImage image, long frameIdx, VkImageLayout srcImageLayout);
+        SharedTexture* CopyColorToLayer(VkCommandBuffer copyCmdBuffer, VkImage image, long frameIdx);
         // AMD GPU FIX: With incrementing values, Vulkan signals odd values (1,3,5...), D3D12 signals even values (2,4,6...)
         // Texture is ready for D3D12 when Vulkan has signaled (odd value > 0)
         bool IsTextureReady(long frameIdx) const {
@@ -166,9 +172,8 @@ class RND_Renderer {
         bool ShouldBlockGameInput() { return ImGui::GetIO().WantCaptureKeyboard; }
 
         void BeginFrame(long frameIdx, bool renderBackground);
-        // AMD GPU FIX: Added srcLayout parameter to specify the actual source image layout
-        static void Draw3DLayerAsBackground(VkCommandBuffer cb, VkImage srcImage, float aspectRatio, long frameIdx, VkImageLayout srcLayout);
-        static void DrawHUDLayerAsBackground(VkCommandBuffer cb, VkImage srcImage, long frameIdx, VkImageLayout srcLayout);
+        static void Draw3DLayerAsBackground(VkCommandBuffer cb, VkImage srcImage, float aspectRatio, long frameIdx);
+        static void DrawHUDLayerAsBackground(VkCommandBuffer cb, VkImage srcImage, long frameIdx);
         void Update();
         void Render();
         void DrawAndCopyToImage(VkCommandBuffer cb, VkImage destImage, long frameIdx);
@@ -181,6 +186,9 @@ class RND_Renderer {
         HWND m_cemuRenderWindow = nullptr;
 
         VkSampler m_sampler = VK_NULL_HANDLE;
+
+        bool m_showAppMS = false;
+        bool m_wasF3Pressed = false;
     };
 
     std::unique_ptr<Layer3D> m_layer3D;
@@ -205,4 +213,17 @@ class RND_Renderer {
 
     std::atomic_bool m_isInitialized = false;
     std::atomic_bool m_presented2DLastFrame = false;
+
+    // Full-frame timing derived from OpenXR timestamps (XrTime is in nanoseconds)
+    XrTime m_lastPredictedDisplayTime = 0;
+
+    std::chrono::high_resolution_clock::time_point m_frameStartTime;
+
+    double m_lastFrameWorkTimeMs = 0.0;
+    double m_lastWaitTimeMs = 0.0;
+
+    // Derived from OpenXR timestamps
+    double m_lastFrameTimeMs = 0.0;
+    double m_predictedDisplayPeriodMs = 0.0;
+    double m_lastOverheadMs = 0.0;
 };

src/rendering/renderer.cpp

@@ -60,6 +60,7 @@ ID3D12Resource* Swapchain<T>::StartRendering() {
     if (XrResult waitResult = xrWaitSwapchainImage(m_swapchain, &waitSwapchainInfo); waitResult == XR_TIMEOUT_EXPIRED || XR_FAILED(waitResult)) {
         checkXRResult(waitResult, "Failed to wait for swapchain image!");
     }
+
     return m_swapchainTextures[m_swapchainImageIdx].Get();
 }