Add Riding height offset; Cleanup Settings

Author: oneup03

src/hooking/camera.cpp

@@ -74,6 +74,11 @@ static glm::mat4 calculateProjectionMatrix(float nearZ, float farZ, const XrFovf
 static glm::fvec3 ApplyCameraModeEyePosPolicy(glm::fvec3 eyePos, CameraMode cameraMode) {
     if (cameraMode == CameraMode::ORIGINAL) {
         eyePos.y = 0.0f;
+
+        auto gameState = VRManager::instance().XR->m_gameState.load();
+        if (gameState.is_riding_mount) {
+            eyePos.y += GetSettings().GetOriginalRidingVerticalOffset();
+        }
     }
 
     return eyePos;
@@ -177,23 +182,25 @@ void CemuHooks::hook_UpdateCameraForGameplay(PPCInterpreter_t* hCPU) {
     s_wsCameraPosition = oldCameraPosition;
     s_wsCameraRotation = glm::quat_cast(glm::inverse(existingGameMtx));
 
-    // rebase the rotation to the player position
-    if (IsFirstPerson()) {
-        // check if player is swimming
-        Player actor;
-        readMemory(s_playerAddress, &actor);
+     // check if player is swimming
+    Player actor;
+    readMemory(s_playerAddress, &actor);
 
-        PlayerMoveBitFlags moveBits = actor.moveBitFlags.getLE();
-        s_isSwimming = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_SWIMMING_OR_CLIMBING | PlayerMoveBitFlags::IS_SWIMMING);
-        s_isCrouching = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_CROUCHING);
+    PlayerMoveBitFlags moveBits = actor.moveBitFlags.getLE();
+    s_isSwimming = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_SWIMMING_OR_CLIMBING | PlayerMoveBitFlags::IS_SWIMMING);
+    s_isCrouching = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_CROUCHING);
 
-        // Todo: move those and their hooks in controls.cpp ?
-        auto gameState = VRManager::instance().XR->m_gameState.load();
-        // Unreliable flag, need to investigate
-        gameState.is_climbing = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_SWIMMING_OR_CLIMBING | PlayerMoveBitFlags::IS_CLIMBING_WALL) || s_isLadderClimbing == 2;
-        gameState.is_riding_mount = (s_isRiding == 2 || s_isRidingSandSeal == 2) ? true : false;
-        gameState.is_paragliding = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_GLIDER_ACTIVE);
-        VRManager::instance().XR->m_gameState.store(gameState);
+    // Todo: move those and their hooks in controls.cpp ?
+    auto gameState = VRManager::instance().XR->m_gameState.load();
+    // Unreliable flag, need to investigate
+    gameState.is_climbing = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_SWIMMING_OR_CLIMBING | PlayerMoveBitFlags::IS_CLIMBING_WALL) || s_isLadderClimbing == 2;
+    gameState.is_riding_mount = (s_isRiding == 2 || s_isRidingSandSeal == 2) ? true : false;
+    gameState.is_paragliding = HAS_FLAG(moveBits, PlayerMoveBitFlags::IS_GLIDER_ACTIVE);
+    VRManager::instance().XR->m_gameState.store(gameState);
+
+    // rebase the rotation to the player position
+    if (IsFirstPerson()) {
+       
 
         auto now = std::chrono::steady_clock::now();
         std::chrono::milliseconds crouchLerpDuration{ 150 };
@@ -244,19 +251,21 @@ void CemuHooks::hook_UpdateCameraForGameplay(PPCInterpreter_t* hCPU) {
         if (s_isLadderClimbing > 0) {
             s_isLadderClimbing--;
         }
-        if (s_isRiding > 0) {
-            s_isRiding--;
-        }
-        if (s_isRidingSandSeal > 0) {
-            s_isRidingSandSeal--;
-        }
+        
 
         s_wasCrouching = s_isCrouching;
 
         glm::mat4 playerMtx4 = glm::inverse(glm::translate(glm::identity<glm::mat4>(), playerPos) * glm::mat4(s_wsCameraRotation));
         existingGameMtx = playerMtx4;
     }
 
+    if (s_isRiding > 0) {
+        s_isRiding--;
+    }
+    if (s_isRidingSandSeal > 0) {
+        s_isRidingSandSeal--;
+    }
+
     // current VR headset camera matrix
     auto viewsOpt = VRManager::instance().XR->GetRenderer()->GetMiddlePose();
     if (!viewsOpt) {
@@ -1122,7 +1131,7 @@ void CemuHooks::hook_PlayerIsRiding(PPCInterpreter_t* hCPU) {
     hCPU->instructionPointer = hCPU->sprNew.LR;
 
     bool isRiding = hCPU->gpr[3] == 1;
-    if (isRiding && IsFirstPerson()) {
+    if (isRiding && (IsFirstPerson() || GetSettings().GetCameraMode() == CameraMode::ORIGINAL)) {
         s_isRiding = 2;
     }
 }
@@ -1131,7 +1140,7 @@ void CemuHooks::hook_PlayerIsRidingSandSeal(PPCInterpreter_t* hCPU) {
     hCPU->instructionPointer = hCPU->sprNew.LR;
 
     bool isRiding = hCPU->gpr[3] == 1;
-    if (isRiding && IsFirstPerson()) {
+    if (isRiding && (IsFirstPerson() || GetSettings().GetCameraMode() == CameraMode::ORIGINAL)) {
         s_isRidingSandSeal = 2;
     }
 }

src/rendering/vulkan_imgui.cpp

@@ -374,7 +374,7 @@ void RND_Renderer::ImGuiOverlay::Render(long frameIdx, bool renderBackground) {
     };
 
     if (renderBackground || CemuHooks::UseBlackBarsDuringEvents()) {
-        const bool shouldCrop3DTo16_9 = GetSettings().cropFlatTo16x9 == 1;
+        const bool shouldCrop3DTo16_9 = GetSettings().ShouldFlatPreviewBeCroppedTo16x9();
 
         bool shouldRender3DBackground = VRManager::instance().XR->GetRenderer()->IsRendering3D(frameIdx) || CemuHooks::UseBlackBarsDuringEvents();
         bool shouldRenderHUDWithAlpha = shouldRender3DBackground && !CemuHooks::UseBlackBarsDuringEvents();
@@ -738,8 +738,16 @@ void RND_Renderer::ImGuiOverlay::DrawHelpMenu() {
                     ImGui::PopStyleColor();
                     if (cameraMode == CameraMode::THIRD_PERSON || cameraMode == CameraMode::ORIGINAL) {
                         DrawSettingRow("Camera Distance", [&]() {
-                            settings.thirdPlayerDistance.AddSliderToGUI(&changed, 0.5f, 0.65f);
+                            settings.thirdPlayerDistance.AddSliderToGUI(&changed, 0.5f, 1.0f);
                         });
+
+                        if (cameraMode == CameraMode::ORIGINAL) {
+                            DrawSettingRow("Riding Vertical Offset", [&]() {
+                                settings.originalRidingVerticalOffset.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) {
+                                    return std::format("{:+.2f}m", value);
+                                });
+                            });
+                        }
                     }
                     else {
                         DrawSettingRow("Height Offset", [&]() {
@@ -784,9 +792,11 @@ void RND_Renderer::ImGuiOverlay::DrawHelpMenu() {
                         });
                     }
 
-                    DrawSettingRow("Black Bars In Third-Person Cutscenes", [&]() {
-                        settings.useBlackBarsForCutscenes.AddToGUI(&changed);
-                    });
+                    if (cameraMode != CameraMode::ORIGINAL) {
+                        DrawSettingRow("Black Bars In Third-Person Cutscenes", [&]() {
+                            settings.useBlackBarsForCutscenes.AddToGUI(&changed);
+                        });
+                    }
 
                     DrawSettingRow("Stereo Depth In Cutscenes", [&]() {
                         settings.cutsceneStereoDepthScale.AddToGUI(&changed, windowWidth.x, 0.0f, 1.5f, [](float value) { return std::format("{:.2f}x", value); });
@@ -797,13 +807,50 @@ void RND_Renderer::ImGuiOverlay::DrawHelpMenu() {
                     ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetStyleColorVec4(ImGuiCol_HeaderActive));
                     ImGui::Text("UI");
                     ImGui::PopStyleColor();
-                    DrawSettingRow("UI Follows Where You Look", [&]() {
-                        settings.uiFollowsGaze.AddToGUI(&changed);
-                    });
+                    if (cameraMode != CameraMode::ORIGINAL) {
+                        DrawSettingRow("UI Follows Where You Look", [&]() {
+                            settings.uiFollowsGaze.AddToGUI(&changed);
+                        });
+                    }
 
                     ImGui::Spacing();
                     DrawLayerSettingsRow("Menu/HUD Distance & Size", &changed, settings.hudDistance, settings.hudSize);
 
+                    ImGui::Spacing();
+                    DrawSettingRow("Enable 3D Static Reticle", [&]() {
+                        settings.enableStaticReticle.AddToGUI(&changed);
+                    });
+
+                    if (settings.enableStaticReticle.Get()) {
+                        DrawSettingRow("Reticle 3D Separation", [&]() {
+                            settings.staticReticlePixelOffsetPx.AddToGUI(&changed, windowWidth.x, 0.0f, 500.0f, [](float value) { return std::format("{:.1f} px", value); });
+                        });
+
+                        DrawSettingRow("Reticle Radius", [&]() {
+                            settings.staticReticleRadiusPx.AddToGUI(&changed, windowWidth.x, 1.0f, 64.0f, [](float value) { return std::format("{:.1f} px", value); });
+                        });
+
+                        DrawSettingRow("Reticle Thickness", [&]() {
+                            settings.staticReticleThicknessPx.AddToGUI(&changed, windowWidth.x, 1.0f, 8.0f, [](float value) { return std::format("{:.1f} px", value); });
+                        });
+
+                        DrawSettingRow("Reticle Opacity", [&]() {
+                            settings.staticReticleOpacity.AddToGUI(&changed, windowWidth.x, 0.1f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
+                        });
+
+                        DrawSettingRow("Reticle Color R", [&]() {
+                            settings.staticReticleColorR.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
+                        });
+
+                        DrawSettingRow("Reticle Color G", [&]() {
+                            settings.staticReticleColorG.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
+                        });
+
+                        DrawSettingRow("Reticle Color B", [&]() {
+                            settings.staticReticleColorB.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
+                        });
+                    }
+
                     ImGui::Spacing();
                     if (cameraMode == CameraMode::FIRST_PERSON) {
                         ImGui::Separator();
@@ -823,9 +870,11 @@ void RND_Renderer::ImGuiOverlay::DrawHelpMenu() {
                     }
 
                     if (ImGui::CollapsingHeader("Advanced Settings")) {
-                        DrawSettingRow("Crop VR Image To 16:9 For Cemu Window", [&]() {
-                            settings.cropFlatTo16x9.AddToGUI(&changed);
-                        });
+                        if (cameraMode != CameraMode::ORIGINAL) {
+                            DrawSettingRow("Crop VR Image To 16:9 For Cemu Window", [&]() {
+                                settings.cropFlatTo16x9.AddToGUI(&changed);
+                            });
+                        }
 
                         DrawSettingRow("Show Debugging Overlays (for developers)", [&]() {
                             settings.enableDebugOverlay.AddToGUI(&changed);
@@ -837,40 +886,6 @@ void RND_Renderer::ImGuiOverlay::DrawHelpMenu() {
                             });
                         }
 
-                        DrawSettingRow("Enable 3D Static Reticle", [&]() {
-                            settings.enableStaticReticle.AddToGUI(&changed);
-                        });
-
-                        if (settings.enableStaticReticle.Get()) {
-                            DrawSettingRow("Reticle 3D Separation", [&]() {
-                                settings.staticReticlePixelOffsetPx.AddToGUI(&changed, windowWidth.x, 0.0f, 500.0f, [](float value) { return std::format("{:.1f} px", value); });
-                            });
-
-                            DrawSettingRow("Reticle Radius", [&]() {
-                                settings.staticReticleRadiusPx.AddToGUI(&changed, windowWidth.x, 1.0f, 64.0f, [](float value) { return std::format("{:.1f} px", value); });
-                            });
-
-                            DrawSettingRow("Reticle Thickness", [&]() {
-                                settings.staticReticleThicknessPx.AddToGUI(&changed, windowWidth.x, 1.0f, 8.0f, [](float value) { return std::format("{:.1f} px", value); });
-                            });
-
-                            DrawSettingRow("Reticle Opacity", [&]() {
-                                settings.staticReticleOpacity.AddToGUI(&changed, windowWidth.x, 0.1f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
-                            });
-
-                            DrawSettingRow("Reticle Color R", [&]() {
-                                settings.staticReticleColorR.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
-                            });
-
-                            DrawSettingRow("Reticle Color G", [&]() {
-                                settings.staticReticleColorG.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
-                            });
-
-                            DrawSettingRow("Reticle Color B", [&]() {
-                                settings.staticReticleColorB.AddToGUI(&changed, windowWidth.x, 0.0f, 1.0f, [](float value) { return std::format("{:.2f}", value); });
-                            });
-                        }
-
                         if (VRManager::instance().XR->m_capabilities.isOculusLinkRuntime) {
                             DrawSettingRow("Angular Velocity Fixer", [&]() {
                                 settings.buggyAngularVelocity.AddComboToGUI(&changed, ModSettings::toDisplayString);

src/utils/mod_settings.h

@@ -650,7 +650,8 @@ struct ModSettings {
     // playing mode settings
     EnumSetting<CameraMode> cameraMode = EnumSetting<CameraMode>("CameraMode", CameraMode::FIRST_PERSON, ModSettings::toString, { CameraMode::FIRST_PERSON, CameraMode::THIRD_PERSON, CameraMode::ORIGINAL });
     EnumSetting<PlayMode> playMode = EnumSetting<PlayMode>("PlayMode", PlayMode::STANDING, ModSettings::toString, { PlayMode::STANDING, PlayMode::SEATED });
-    FloatSetting<float> thirdPlayerDistance = FloatSetting<float>("ThirdPlayerDistance", 0.5f, 0.0f);
+    FloatSetting<float> thirdPlayerDistance = FloatSetting<float>("ThirdPlayerDistance", 0.5f, 0.0f, 1.0f);
+    FloatSetting<float> originalRidingVerticalOffset = FloatSetting<float>("OriginalRidingVerticalOffset", 0.4f, 0.0f, 1.0f);
     EnumSetting<EventMode> cutsceneCameraMode = EnumSetting<EventMode>("CutsceneCameraMode", EventMode::FOLLOW_DEFAULT_EVENT_SETTINGS, ModSettings::toString, { EventMode::ALWAYS_FIRST_PERSON, EventMode::FOLLOW_DEFAULT_EVENT_SETTINGS, EventMode::ALWAYS_THIRD_PERSON });
     FloatSetting<float> gameplayStereoDepthScale = FloatSetting<float>("GameplayStereoDepthScale", kDefaultGameplayStereoDepthScale, 0.0f, 3.0f);
     FloatSetting<float> cutsceneStereoDepthScale = FloatSetting<float>("CutsceneStereoDepthScale", kDefaultCutsceneStereoDepthScale, 0.0f, 1.5f);
@@ -689,6 +690,7 @@ struct ModSettings {
             &cameraMode,
             &playMode,
             &thirdPlayerDistance,
+            &originalRidingVerticalOffset,
             &cutsceneCameraMode,
             &gameplayStereoDepthScale,
             &cutsceneStereoDepthScale,
@@ -721,7 +723,12 @@ struct ModSettings {
     CameraMode GetCameraMode() const { return cameraMode; }
 
     PlayMode GetPlayMode() const { return playMode; }
-    bool DoesUIFollowGaze() const { return uiFollowsGaze; }
+    bool DoesUIFollowGaze() const {
+        if (GetCameraMode() == CameraMode::ORIGINAL) {
+            return false;
+        }
+        return uiFollowsGaze;
+    }
     bool IsLeftHanded() const { return leftHanded; }
     float GetPlayerHeightOffset() const {
         // disable height offset in third-person-style modes
@@ -740,8 +747,19 @@ struct ModSettings {
     }
     float GetGameplayStereoDepthScale() const { return gameplayStereoDepthScale; }
     float GetCutsceneStereoDepthScale() const { return cutsceneStereoDepthScale; }
-    bool UseBlackBarsForCutscenes() const { return useBlackBarsForCutscenes; }
-    bool ShouldFlatPreviewBeCroppedTo16x9() const { return cropFlatTo16x9 == 1; }
+    float GetOriginalRidingVerticalOffset() const { return originalRidingVerticalOffset; }
+    bool UseBlackBarsForCutscenes() const {
+        if (GetCameraMode() == CameraMode::ORIGINAL) {
+            return false;
+        }
+        return useBlackBarsForCutscenes;
+    }
+    bool ShouldFlatPreviewBeCroppedTo16x9() const {
+        if (GetCameraMode() == CameraMode::ORIGINAL) {
+            return true;
+        }
+        return cropFlatTo16x9 == 1;
+    }
 
     bool ShowDebugOverlay() const { return enableDebugOverlay; }
     AngularVelocityFixerMode AngularVelocityFixer_GetMode() const { return buggyAngularVelocity; }
@@ -753,6 +771,7 @@ struct ModSettings {
     std::string ToString() const {
         std::string buffer = "";
         std::format_to(std::back_inserter(buffer), " - Camera Mode: {}\n", toDisplayString(GetCameraMode()));
+        std::format_to(std::back_inserter(buffer), " - Original Riding Vertical Offset: {:.2f}m\n", GetOriginalRidingVerticalOffset());
         std::format_to(std::back_inserter(buffer), " - Left Handed: {}\n", IsLeftHanded() ? "Yes" : "No");
         std::format_to(std::back_inserter(buffer), " - GUI Follow Setting: {}\n", DoesUIFollowGaze() ? "Follow Looking Direction" : "Fixed");
         std::format_to(std::back_inserter(buffer), " - Player Height: {} meters\n", GetPlayerHeightOffset());