Fix camera, save file images and inventory background image

Author: Crementif

include/pch.h

@@ -613,4 +613,4 @@ struct data_VRProjectionMatrixOut {
 
 #include "game_structs.h"
 #include "cemu.h"
-#include "utils/logger.h"
+#include "utils/logger.h"

resources/BreathOfTheWild_BetterVR/patch_RND_Find3DFrameBuffer.asm

@@ -177,4 +177,35 @@ blr
 
 
 0x039B3044 = bla hookPostHDRComposedImage
-;0x0397AB30 = cmpw r3, r3
+;0x0397AB30 = cmpw r3, r3
+
+
+; for one frame, disable clearing the framebuffer (used for separating 2D hud from 3D scene)
+custom_turnOnTempLayerCopy:
+mflr r0
+stwu r1, -0x10(r1)
+stw r0, 0x14(r1)
+stw r3, 0x0C(r1)
+stw r4, 0x08(r1)
+stw r5, 0x04(r1)
+
+; original code
+lwz r3, 0x86C(r3)
+li r4, 1
+stb r4, 0x318(r3)
+
+lis r4, currentFrameCounter@ha
+lwz r4, currentFrameCounter@l(r4)
+lis r5, currentEyeSide@ha
+lwz r5, currentEyeSide@l(r5)
+bla import.coreinit.hook_FixCameraSaveFilesAndInventory
+
+lwz r5, 0x04(r1)
+lwz r4, 0x08(r1)
+lwz r3, 0x0C(r1)
+lwz r0, 0x14(r1)
+addi r1, r1, 0x10
+mtlr r0
+blr
+
+0x0340A8A8 = ba custom_turnOnTempLayerCopy

src/hooking/camera.cpp

@@ -2,6 +2,9 @@
 #include "instance.h"
 #include "rendering/openxr.h"
 
+bool CemuHooks::UseMonoFrameBufferTemporarilyDuringMenusOrPictures() {
+    return IsScreenOpen(ScreenId::PauseMenuInfo_00) || VRManager::instance().XR->GetRenderer()->IsGameCapturing3DFrameBuffer();
+}
 
 void CemuHooks::hook_BeginCameraSide(PPCInterpreter_t* hCPU) {
     hCPU->instructionPointer = hCPU->sprNew.LR;
@@ -335,6 +338,11 @@ void CemuHooks::hook_GetRenderProjection(PPCInterpreter_t* hCPU) {
         return;
     }
 
+    if (UseMonoFrameBufferTemporarilyDuringMenusOrPictures()) {
+        return;
+    }
+
+
     uint32_t projectionIn = hCPU->gpr[3];
     uint32_t projectionOut = hCPU->gpr[12];
     OpenXR::EyeSide side = hCPU->gpr[0] == 0 ? EyeSide::LEFT : EyeSide::RIGHT;
@@ -400,6 +408,10 @@ void CemuHooks::hook_ModifyLightPrePassProjectionMatrix(PPCInterpreter_t* hCPU)
     if (UseBlackBarsDuringEvents()) {
         return;
     }
+    
+    if (UseMonoFrameBufferTemporarilyDuringMenusOrPictures()) {
+        return;
+    }
 
     uint32_t projectionIn = hCPU->gpr[3];
     OpenXR::EyeSide side = hCPU->gpr[11] == 0 ? EyeSide::LEFT : EyeSide::RIGHT;
@@ -463,6 +475,10 @@ void CemuHooks::hook_ModifyProjectionUsingCamera(PPCInterpreter_t* hCPU) {
         return;
     }
 
+    if (UseMonoFrameBufferTemporarilyDuringMenusOrPictures()) {
+        return;
+    }
+
     uint32_t projectionPtr = hCPU->gpr[4];
     uint32_t cameraPtr = hCPU->gpr[7];
     OpenXR::EyeSide side = hCPU->gpr[5] == 0 ? EyeSide::LEFT : EyeSide::RIGHT;

src/hooking/cemu_hooks.h

@@ -71,6 +71,7 @@ class CemuHooks {
         osLib_registerHLEFunction("coreinit", "hook_ModifyHandModelAccessSearch", &hook_ModifyHandModelAccessSearch);
         osLib_registerHLEFunction("coreinit", "hook_CreateNewScreen", &hook_CreateNewScreen);
         osLib_registerHLEFunction("coreinit", "hook_FixUIBlending", &hook_FixUIBlending);
+        osLib_registerHLEFunction("coreinit", "hook_FixCameraSaveFilesAndInventory", &hook_FixCameraSaveFilesAndInventory);
     };
     ~CemuHooks() {
         FreeLibrary(m_cemuHandle);

src/hooking/framebuffer.cpp

@@ -40,6 +40,19 @@ void VkDeviceOverrides::DestroyImage(const vkroots::VkDeviceDispatch& pDispatch,
     pDispatch.DestroyImage(device, image, pAllocator);
 }
 
+
+void CemuHooks::hook_FixCameraSaveFilesAndInventory(PPCInterpreter_t* hCPU) {
+    hCPU->instructionPointer = hCPU->sprNew.LR;
+
+    uint32_t isEnabling3DFramebufferCapture = hCPU->gpr[3];
+    EyeSide side = (EyeSide)hCPU->gpr[4];
+    uint32_t frameIdx = hCPU->gpr[5];
+
+    Log::print<PPC>("hook_FixCameraSaveFilesAndInventory: isEnabling3DFramebufferCapture={}, side={}, frameIdx={}", isEnabling3DFramebufferCapture, side, frameIdx);
+    VRManager::instance().XR->GetRenderer()->SignalGameCapturing3DFrameBuffer();
+}
+
+
 void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatch& pDispatch, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
     // check whether the magic values are there, and which order they are in to determine which eye
     OpenXR::EyeSide side = (OpenXR::EyeSide)-1;
@@ -128,6 +141,13 @@ void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatc
             VulkanUtils::DebugPipelineBarrier(commandBuffer);
         };
 
+        RND_Renderer::RenderFrame& frame = renderer->GetFrame(frameIdx);
+
+        auto clearFramebuffer = [&](bool disableAlpha) -> void {
+            VkClearColorValue clearColor = disableAlpha ? VkClearColorValue{ { 0.0f, 0.0f, 0.0f, 1.0f } } : VkClearColorValue{ { 0.0f, 0.0f, 0.0f, 0.0f } };
+            pDispatch.CmdClearColorImage(commandBuffer, image, imageLayout, &clearColor, rangeCount, pRanges);
+        };
+
         // 3D layer - color texture for 3D rendering
         if (captureIdx == 0) {
             // check if the color texture has the appropriate texture format
@@ -149,24 +169,19 @@ void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatc
 
             if (image != s_curr3DColorImage) {
                 Log::print<RENDERING>("Color image is not the same as the current 3D color image! ({} != {})", (void*)image, (void*)s_curr3DColorImage);
-                VkClearColorValue clearColor;
-                if (VRManager::instance().XR->GetRenderer()->IsRendering3D(frameIdx)) {
-                    clearColor = {{ 0.0f, 0.0f, 0.0f, 0.0f }};
-                }
-                else {
-                    clearColor = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
-                }
                 returnToLayout();
-                return pDispatch.CmdClearColorImage(commandBuffer, image, imageLayout, &clearColor, rangeCount, pRanges);
+                return clearFramebuffer(!VRManager::instance().XR->GetRenderer()->IsRendering3D(frameIdx));
             }
 
             if (renderer->GetFrame(frameIdx).copiedColor[side]) {
                 // the color texture has already been copied to the layer
                 Log::print<RENDERING>("A 3D color texture is already been copied for the current frame!");
 
-                VkClearColorValue clearColor = {{ 0.0f, 0.0f, 0.0f, 0.0f }};
                 returnToLayout();
-                return pDispatch.CmdClearColorImage(commandBuffer, image, imageLayout, &clearColor, rangeCount, pRanges);
+                if (CemuHooks::UseMonoFrameBufferTemporarilyDuringMenusOrPictures()) {
+                    return;
+                }
+                return clearFramebuffer(false);
             }
 
             // note: This uses vkCmdCopyImage to copy the image to the D3D12-created interop texture. s_activeCopyOperations queues a semaphore for the D3D12 side to wait on.
@@ -178,6 +193,10 @@ void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatc
                 s_activeCopyOperations.emplace_back(commandBuffer, texture);
             }
 
+            if (CemuHooks::UseMonoFrameBufferTemporarilyDuringMenusOrPictures()) {
+                return;
+            }
+
             // imgui needs only one eye to render Cemu's 2D output, so use right side since it looks better
             if (side == EyeSide::RIGHT) {
                 // note: Uses vkCmdCopyImage to copy the (right-eye-only) image to the imgui overlay's texture
@@ -186,23 +205,21 @@ void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatc
             }
 
             // clear the image to be transparent to allow for the HUD to be rendered on top of it which results in a transparent HUD layer
-            VkClearColorValue clearColor = {{ 0.0f, 0.0f, 0.0f, 0.0f }};
             returnToLayout();
-            return pDispatch.CmdClearColorImage(commandBuffer, image, imageLayout, &clearColor, rangeCount, pRanges);
+            return clearFramebuffer(false);
         }
 
         // 2D layer - color texture for HUD rendering
         if (captureIdx == 2) {
             bool hudCopied = renderer->GetFrame(frameIdx).copied2D;
 
-            if (side == OpenXR::EyeSide::LEFT) {
+            if (side == EyeSide::LEFT) {
                 if (hudCopied) {
                     // the 2D texture has already been copied to the layer
                     Log::print<RENDERING>("A 2D texture has already been copied for the current frame!");
 
-                    VkClearColorValue clearColor = {{ 0.0f, 0.0f, 0.0f, 0.0f }};
                     returnToLayout();
-                    return pDispatch.CmdClearColorImage(commandBuffer, image, imageLayout, &clearColor, rangeCount, pRanges);
+                    return clearFramebuffer(false);
                 }
                 else {
                     // provide the HUD texture to the imgui overlay we'll use to recomposite Cemu's original flatscreen rendering
@@ -232,7 +249,7 @@ void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatc
                     return;
                 }
             }
-            if (side == OpenXR::EyeSide::RIGHT) {
+            if (side == EyeSide::RIGHT) {
                 // render the imgui overlay on the right side
                 if (imguiOverlay) {
                     // render imgui, and then copy the framebuffer to the 2D layer
@@ -244,12 +261,12 @@ void VkDeviceOverrides::CmdClearColorImage(const vkroots::VkCommandBufferDispatc
                 }
 
                 if (hudCopied) {
-                    VkClearColorValue clearColor = {{ 0.0f, 0.0f, 0.0f, 0.0f }};
                     returnToLayout();
-                    return pDispatch.CmdClearColorImage(commandBuffer, image, imageLayout, &clearColor, rangeCount, pRanges);
+                    return clearFramebuffer(false);
                 }
             }
         }
+        returnToLayout();
         return;
     }
     else {

src/rendering/renderer.cpp

@@ -130,6 +130,11 @@ void RND_Renderer::EndFrame() {
         m_renderFrames[frameIdx].Reset();
     }
 
+    // decrement camera capture counter since its active only for a few frames
+    if (m_cameraIsCapturing3DFrameBuffer > 0) {
+        --m_cameraIsCapturing3DFrameBuffer;
+    }
+
     m_lastFrameWorkTimeMs = std::chrono::duration<double, std::milli>(std::chrono::high_resolution_clock::now() - m_frameStartTime).count();
 
     XrFrameEndInfo frameEndInfo = { XR_TYPE_FRAME_END_INFO };

src/rendering/renderer.h

@@ -19,6 +19,7 @@ class RND_Renderer {
         std::atomic_bool copiedDepth[2] = { false, false };
         std::atomic_bool copied2D = false;
         std::atomic_bool presented3D = false;
+        std::atomic_uint8_t cameraIsCapturing3DFramebuffer = 0;
 
         std::unique_ptr<VulkanTexture> mainFramebuffer;
         std::unique_ptr<VulkanTexture> hudFramebuffer;
@@ -41,6 +42,8 @@ class RND_Renderer {
             copiedDepth[0] = false;
             copiedDepth[1] = false;
             copied2D = false;
+            if (cameraIsCapturing3DFramebuffer > 0)
+                --cameraIsCapturing3DFramebuffer;
 
             ranMotionAnalysis[0] = false;
             ranMotionAnalysis[1] = false;
@@ -209,6 +212,12 @@ class RND_Renderer {
     bool IsInitialized() {
         return m_isInitialized;
     }
+    bool IsGameCapturing3DFrameBuffer() const {
+        return m_cameraIsCapturing3DFrameBuffer > 0;
+    }
+    void SignalGameCapturing3DFrameBuffer() {
+        m_cameraIsCapturing3DFrameBuffer = 1;
+    }
 
 protected:
     XrSession m_session;
@@ -218,6 +227,7 @@ class RND_Renderer {
 
     std::atomic_bool m_isInitialized = false;
     std::atomic_bool m_presented2DLastFrame = false;
+    std::atomic_uint8_t m_cameraIsCapturing3DFrameBuffer = 0;
 
     // Full-frame timing derived from OpenXR timestamps (XrTime is in nanoseconds)
     XrTime m_lastPredictedDisplayTime = 0;