From 6ad7b4ec439da56d68b871a2a98898dd1b85ed12 Mon Sep 17 00:00:00 2001 From: Andrew Opalach Date: Sun, 23 Mar 2025 13:29:27 -0400 Subject: Add config/presets and some fixes --- Config.cs | 81 +++++++++ MHWNewCamera.csproj | 2 +- Plugin.cs | 495 +++++++++++++++++++++++++++++++++++----------------- 3 files changed, 416 insertions(+), 162 deletions(-) create mode 100755 Config.cs diff --git a/Config.cs b/Config.cs new file mode 100755 index 0000000..eedd19c --- /dev/null +++ b/Config.cs @@ -0,0 +1,81 @@ +using SharpPluginLoader.Core.Configuration; +using SharpPluginLoader.Core.IO; + +namespace MHWNewCamera +{ + internal class Config : IConfig + { + public struct Binds + { + public Binds() + { + ToggleFreeCamera = Key.NumPad0; + TogglePerspectiveCamera = Key.NumPadPeriod; + /* + IncreaseSpeed = Key.NumPadPlus; + DecreaseSpeed = Key.NumPadMinus; + IncreaseFOV = Key.PageUp; + DecreaseFOV = Key.PageDown; + Forward = Key.Up; + Backward = Key.Down; + Left = Key.Left; + Right = Key.Right; + Up = Key.NumPad4; + Down = Key.NumPad1; + */ + } + public Key ToggleFreeCamera { get; set; } + public Key TogglePerspectiveCamera { get; set; } + /* + public Key IncreaseSpeed { get; set; } + public Key DecreaseSpeed { get; set; } + public Key IncreaseFOV { get; set; } + public Key DecreaseFOV { get; set; } + public Key Forward { get; set; } + public Key Backward { get; set; } + public Key Up { get; set; } + public Key Down { get; set; } + public Key Left { get; set; } + public Key Right { get; set; } + */ + } + + public struct Settings + { + public Settings() + { + CameraSpeed = -1.0f; + CameraKeySpeed = -1.0f; + CameraSpeedModifier = -1.0f; + CameraSensitivity = -1.0f; + StickDeadzone = -1; + CameraPitchLimit = -1.0f; + } + public float CameraSpeed { get; set; } + public float CameraKeySpeed { get; set; } + public float CameraSpeedModifier { get; set; } + public float CameraSensitivity { get; set; } + public int StickDeadzone { get; set; } + public float CameraPitchLimit { get; set; } + } + + public struct Preset + { + public float FOV { get; set; } + public float Forward { get; set; } + public float Left { get; set; } + public float Up { get; set; } + public float Roll { get; set; } + } + + public string Name => "MHWNewCamera"; + public string Version => "1.0.0"; + + public Binds KeyboardBinds { get; set; } = new Binds(); + public Settings CameraSettings { get; set; } = new Settings(); + public bool KeyboardEnabled { get; set; } = false; + public bool PerspectiveCameraEnabled { get; set; } = false; + public Dictionary Presets { get; set; } = new Dictionary(); + public string Selected { get; set; } = ""; + } +} diff --git a/MHWNewCamera.csproj b/MHWNewCamera.csproj index bca96e6..760cd41 100755 --- a/MHWNewCamera.csproj +++ b/MHWNewCamera.csproj @@ -8,7 +8,7 @@ - + diff --git a/Plugin.cs b/Plugin.cs index b65e96f..6f28300 100755 --- a/Plugin.cs +++ b/Plugin.cs @@ -7,6 +7,7 @@ using SharpPluginLoader.Core.View; using SharpPluginLoader.Core.Memory; using SharpPluginLoader.Core.MtTypes; using SharpPluginLoader.Core.Actions; +using SharpPluginLoader.Core.Configuration; namespace MHWNewCamera { @@ -15,50 +16,45 @@ namespace MHWNewCamera public string Name => "MHW New Camera"; public string Author => "pizza"; - private float cameraFov = 60.0f; + public const float DEFAULT_FOV = 60.0f; + public const float DEFAULT_SPEED = 0.55f; + public const float DEFAULT_KEY_SPEED = 0.2f; + public const float DEFAULT_SPEED_MODIFIER = 0.4f; + public const float DEFAULT_SENSITIVITY = 0.112f; + public const int DEFAULT_DEADZONE = 4750; + public const float DEFAULT_PITCH_LIMIT = 88.25f; + + private float cameraFov = DEFAULT_FOV; private float cameraForward = 0.0f; private float cameraLeft = 0.0f; private float cameraXOffset = 0.0f; private float cameraYOffset = 0.0f; private float cameraZOffset = 0.0f; - private float cameraKeySpeed = 0.08f; - private float cameraSpeed = 0.55f; - private float cameraSensitivity = 0.112f; - private int stickDeadzone = 4500; + private float cameraSpeed; + private float cameraKeySpeed; + private float cameraSpeedModifier; + private float cameraSensitivity; + private int stickDeadzone; + private float cameraPitchLimit; + private float cameraPitch = 0.0f; private float cameraYaw = 0.0f; private float cameraRoll = 0.0f; - public struct Binds { - public Key ToggleFreeCamera; - public Key TogglePerspectiveCamera; - public Key IncreaseSpeed; - public Key DecreaseSpeed; - public Key IncreaseFOV; - public Key DecreaseFOV; - public Key Forward; - public Key Backward; - public Key Up; - public Key Down; - public Key Left; - public Key Right; - }; - - private Binds binds; - private bool freeCamera = false; - private bool enableFreeCamera = false; - private bool movementFreezeHeld = false; - private bool movementFreezeToggled = false; + private bool toggleFreeCamera = false; + private bool unlockMovementHeld = false; + private bool unlockMovementToggled = false; private bool offsetPerspective = false; - private bool enableOffsetPerspective = false; + private bool toggleOffsetPerspective = false; private Camera? targetCamera = null; private float previousFov = -1.0f; private bool decreasingFov = false; private bool changeAfterOpenMap = true; - private bool updateFovInView = false; + private bool changeAfterGetUp = true; + private bool resetFovInView = false; private delegate void CalculateCameraDelegate(nint unknownPtr); private Hook? calculateCameraHook; @@ -77,28 +73,58 @@ namespace MHWNewCamera private bool disableCollision = false; private bool disableExtraCollision = false; + private bool keyboardEnabled; + private Config.Binds keyboardBinds; + + private string typedPresetName = ""; + private static readonly MtObject sMhSteamController = SingletonManager.GetSingleton("sMhSteamController")!; public void OnLoad() { - binds.ToggleFreeCamera = Key.NumPad0; - binds.TogglePerspectiveCamera = Key.NumPadPeriod; - binds.IncreaseSpeed = Key.NumPadPlus; - binds.DecreaseSpeed = Key.NumPadMinus; - binds.IncreaseFOV = Key.PageUp; - binds.DecreaseFOV = Key.PageDown; - binds.Forward = Key.Up; - binds.Backward = Key.Down; - binds.Left = Key.Left; - binds.Right = Key.Right; - // + Control (left or right). - binds.Up = Key.Up; - binds.Down = Key.Down; + Config config = ConfigManager.GetConfig(this); + + Config.Settings settings = config.CameraSettings; + if (settings.CameraSpeed == -1.0f) + settings.CameraSpeed = DEFAULT_SPEED; + if (settings.CameraKeySpeed == -1.0f) + settings.CameraKeySpeed = DEFAULT_KEY_SPEED; + if (settings.CameraSpeedModifier == -1.0f) + settings.CameraSpeedModifier = DEFAULT_SPEED_MODIFIER; + if (settings.CameraSensitivity == -1.0f) + settings.CameraSensitivity = DEFAULT_SENSITIVITY; + if (settings.StickDeadzone == -1) + settings.StickDeadzone = DEFAULT_DEADZONE; + if (settings.CameraPitchLimit == -1.0f) + settings.CameraPitchLimit = DEFAULT_PITCH_LIMIT; + cameraSpeed = settings.CameraSpeed; + cameraKeySpeed = settings.CameraKeySpeed; + cameraSpeedModifier = settings.CameraSpeedModifier; + cameraSensitivity = settings.CameraSensitivity; + stickDeadzone = settings.StickDeadzone; + cameraPitchLimit = settings.CameraPitchLimit; + config.CameraSettings = settings; + + toggleOffsetPerspective = config.PerspectiveCameraEnabled; + if (config.Selected != "") + { + Config.Preset preset = config.Presets[config.Selected]; + cameraFov = preset.FOV; + cameraForward = preset.Forward; + cameraLeft = preset.Left; + cameraYOffset = preset.Up; + cameraRoll = preset.Roll; + } + + keyboardEnabled = config.KeyboardEnabled; + keyboardBinds = config.KeyboardBinds; + + ConfigManager.SaveConfig(this); // Hook where we can adjust the camera position. calculateCameraHook = Hook.Create(0x141fa5380, CalculateCameraHook); - //calculateCameraHook = Hook.Create(0x142290620, CalculateCameraHook); + // Hook where we can directly modify the view matrix. calculateViewHook = Hook.Create(0x14228eb60, CalculateViewHook); //calculateViewHook2 = Hook.Create(0x14228fb80, CalculateViewHook2); @@ -119,7 +145,6 @@ namespace MHWNewCamera private static bool assumeInQuestBoard(float fov) { - // 20.x = quest board return fov == 20.000038f || fov == 20.017189f || fov == 20.00004f; } @@ -131,14 +156,14 @@ namespace MHWNewCamera private bool assumeInOpenMapAnimation(float fov) { - // Assume the camera's fov could end up at 50.942066 during normal - // gameplay. Try to mitigate it by tracking the triggers for opening + // Assume the camera's FOV could end up at 50.942066 during normal + // gameplay. Try to mitigate that by tracking the triggers for opening // the map (press and quickly release select, press A at departure location). // This is a really rough hack but better than nothing for now. if (fov == 50.942066f) { if (!changeAfterOpenMap) return true; - if (Input.IsReleased(Button.Share) || Input.IsPressed(Button.Cross)) + if (Input.IsReleased(Button.Share) || Input.IsPressed(Button.Cross) || Input.IsReleased(Key.M)) { changeAfterOpenMap = false; return true; @@ -150,6 +175,32 @@ namespace MHWNewCamera changeAfterOpenMap = true; } + return false; + } + + private bool assumeInCanteen(float fov, float previousFov) + { + // Same idea as assumeInOpenMapAnimation(). + if (fov == 50.0f) + { + if (!changeAfterGetUp) return true; + // fov = 50.0 is too common, assume the FOV will always be greater than 51.0 + // before sitting at the canteen. Also assuming that if FOV is 50.0 otherwise + // that previousFov will be something closer to 50.0. + if (previousFov >= 51.0f) + { + if (Input.IsPressed(Button.Cross) || (Input.IsDown(Button.Triangle) || Input.IsReleased(Button.Triangle))) + { + changeAfterGetUp = false; + return true; + } + } + } + + if (!changeAfterGetUp) + { + changeAfterGetUp = true; + } return false; } @@ -174,38 +225,55 @@ namespace MHWNewCamera camera.AspectRatio = vp.Region.Height / (float)vp.Region.Width; // Increase FOV for culling then set it back in CalculateViewHook. camera.FieldOfView *= 2.0f; - updateFovInView = true; + resetFovInView = true; + } + + private static Quaternion getForward(Vector3 pos, Vector3 target) + { + return new Quaternion(target.X - pos.X, target.Y - pos.Y, target.Z - pos.Z, 0.0f); } private void CalculateCameraHook(nint unknownPtr) { calculateCameraHook!.Original(unknownPtr); - Camera? camera = targetCamera; Viewport vp = CameraSystem.MainViewport; - if (camera == null) return; + Camera? camera = vp.Camera; + + if (offsetPerspective && !freeCamera) + { + camera = targetCamera; + if (camera == null) return; - Vector3 pos = camera.Position; - Vector3 target = camera.Target; - Quaternion forward = Quaternion.Normalize(new Quaternion(target.X - pos.X, target.Y - pos.Y, target.Z - pos.Z, 0.0f)); + decreasingFov = previousFov >= 0.0f && previousFov > camera.FieldOfView; - decreasingFov = previousFov >= 0.0f && previousFov > camera.FieldOfView; - previousFov = camera.FieldOfView; + bool applyPerspective = camera.Fix && camera.Move; + applyPerspective &= !assumeInQuestBoard(camera.FieldOfView); + applyPerspective &= !(assumeInAnimation(vp, camera) && decreasingFov); + applyPerspective &= !assumeInOpenMapAnimation(camera.FieldOfView); + applyPerspective &= !assumeInCanteen(camera.FieldOfView, previousFov); - if ((offsetPerspective && !freeCamera) && camera.Fix && camera.Move && - !assumeInQuestBoard(camera.FieldOfView) && !(assumeInAnimation(vp, camera) && decreasingFov) && - !assumeInOpenMapAnimation(camera.FieldOfView)) + previousFov = camera.FieldOfView; + + if (applyPerspective) + { + Quaternion forward = Quaternion.Normalize(getForward(camera.Position, camera.Target)); + setPerspective(camera, camera.Position, forward); + if (cameraRoll != 0.0f) adjustForCameraRoll(vp, camera); + } + } + else if (camera != null) { - setPerspective(camera, pos, forward); - if (cameraRoll != 0.0f) adjustForCameraRoll(vp, camera); + // Track this just for the debug display. + previousFov = camera.FieldOfView; } - if (enableFreeCamera && !freeCamera) + if (camera != null && toggleFreeCamera && !freeCamera) { freeCamera = true; camera.Move = false; - pos = camera.Position; - forward = Quaternion.Normalize(new Quaternion(target.X - pos.X, target.Y - pos.Y, target.Z - pos.Z, 0.0f)); + // Camera position could have changed. + Quaternion forward = Quaternion.Normalize(getForward(camera.Position, camera.Target)); cameraPitch = Single.RadiansToDegrees((float)Math.Asin(forward.Y)); cameraYaw = Single.RadiansToDegrees((float)Math.Atan2(forward.Z, forward.X)); } @@ -215,7 +283,7 @@ namespace MHWNewCamera { Viewport vp = CameraSystem.MainViewport; bool updateView = freeCamera || offsetPerspective; - if (updateFovInView) + if (resetFovInView) { if (updateView) { @@ -225,7 +293,7 @@ namespace MHWNewCamera camera.FieldOfView = cameraFov; } } - updateFovInView = false; + resetFovInView = false; } calculateViewHook!.Original(unknownPtr); if (updateView) @@ -236,7 +304,10 @@ namespace MHWNewCamera private float CalculateMovementHook(int stickValue) { - if (freeCamera && !(movementFreezeHeld || movementFreezeToggled)) stickValue = 0; + if (freeCamera && !(unlockMovementHeld || unlockMovementToggled)) + { + stickValue = 0; + } return calculateMovementHook!.Original(stickValue); } @@ -294,61 +365,154 @@ namespace MHWNewCamera public void OnImGuiRender() { - ImGui.Checkbox("Enable Free Camera", ref enableFreeCamera); - if (enableFreeCamera) + Config config = ConfigManager.GetConfig(this); + + ImGui.Checkbox("Enable Free Camera", ref toggleFreeCamera); + if (toggleFreeCamera) { ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * 0.5f); } - ImGui.Checkbox("Enable Perspective Camera", ref enableOffsetPerspective); - if (enableFreeCamera) + if (ImGui.Checkbox("Enable Perspective Camera", ref toggleOffsetPerspective)) + { + // Take the oposite because it's yet to be toggled. + config.PerspectiveCameraEnabled = !offsetPerspective; + ConfigManager.SaveConfig(this); + } + if (toggleFreeCamera) { ImGui.PopStyleVar(); } ImGui.PushID("Perspective"); - if (ImGui.SliderFloat("Field of View", ref cameraFov, 1.0f, 180.0f)) + ImGui.SliderFloat("Field of View", ref cameraFov, 1.0f, 180.0f); + ImGui.SliderFloat("Forward", ref cameraForward, -360.0f, 360.0f); + ImGui.SliderFloat("Left", ref cameraLeft, -360.0f, 360.0f); + ImGui.SliderFloat("Up", ref cameraYOffset, -360.0f, 360.0f); + if (ImGui.Button("Default")) { - } - ImGui.SliderFloat("Forward", ref cameraForward, -300.0f, 300.0f); - ImGui.SliderFloat("Left", ref cameraLeft, -300.0f, 300.0f); - ImGui.SliderFloat("Up", ref cameraYOffset, -300.0f, 300.0f); - if (ImGui.Button("Reset")) - { - cameraFov = 60.0f; + cameraFov = DEFAULT_FOV; cameraForward = 0.0f; cameraLeft = 0.0f; cameraXOffset = 0.0f; cameraYOffset = 0.0f; cameraZOffset = 0.0f; + config.Selected = ""; + ConfigManager.SaveConfig(this); } + ImGui.SameLine(); + if (ImGui.Button("Save")) + { + String name = typedPresetName; + if (name != "") + { + Config.Preset preset = new Config.Preset(); + preset.FOV = cameraFov; + preset.Forward = cameraForward; + preset.Left = cameraLeft; + preset.Up = cameraYOffset; + preset.Roll = cameraRoll; + if (config.Presets.ContainsKey(name)) + { + config.Presets[name] = preset; + } + else + { + config.Presets.Add(name, preset); + } + config.Selected = name; + ConfigManager.SaveConfig(this); + } + } + ImGui.SameLine(); + ImGui.PushItemWidth(170); + ImGui.InputText("##Preset Name", ref typedPresetName, 99); + ImGui.SameLine(); + if (ImGui.BeginCombo("##Preset", config.Selected)) + { + Dictionary.KeyCollection presetKeys = config.Presets.Keys; + for (int i = 0; i < presetKeys.Count; i++) + { + string key = presetKeys.ElementAt(i); + bool isSelected = key == config.Selected; + if (ImGui.Selectable(key, isSelected)) + { + config.Selected = key; + ConfigManager.SaveConfig(this); + Config.Preset preset = config.Presets[config.Selected]; + cameraFov = preset.FOV; + cameraForward = preset.Forward; + cameraLeft = preset.Left; + cameraYOffset = preset.Up; + cameraRoll = preset.Roll; + } + if (isSelected) + { + ImGui.SetItemDefaultFocus(); + } + } + ImGui.EndCombo(); + } + ImGui.PopItemWidth(); ImGui.PopID(); ImGui.PushID("Settings"); - ImGui.SliderFloat("Camera Keybind Speed", ref cameraKeySpeed, 0.01f, 3.0f); + ImGui.SliderFloat("Camera Speed", ref cameraSpeed, 0.1f, 10.0f); if (ImGui.BeginItemTooltip()) { - ImGui.Text("Camera Adjustment Keybinds"); + ImGui.Text("Movement speed in freecam."); ImGui.EndTooltip(); } - ImGui.SliderFloat("Camera Speed", ref cameraSpeed, 0.1f, 10.0f); + ImGui.SliderFloat("Button Speed", ref cameraKeySpeed, 0.01f, 3.0f); if (ImGui.BeginItemTooltip()) { - ImGui.Text("Camera Movement in Free Camera"); + ImGui.Text("Rate of camera adjustment buttons/keybinds."); + ImGui.EndTooltip(); + } + ImGui.SliderFloat("Speed Modifier", ref cameraSpeedModifier, 0.1f, 10.0f); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Value to multiply speed by when L2 is held."); ImGui.EndTooltip(); } ImGui.SliderFloat("Camera Sensitivity", ref cameraSensitivity, 0.005f, 1.00f); if (ImGui.BeginItemTooltip()) { - ImGui.Text("Camera Sensitivity in Free Camera"); + ImGui.Text("Camera look sensitivity in freecam."); ImGui.EndTooltip(); } - ImGui.InputInt("Stick Deadzone", ref stickDeadzone); + ImGui.InputInt("Stick Deadzone", ref stickDeadzone, 10); + if (ImGui.Button("Default")) + { + cameraSpeed = DEFAULT_SPEED; + cameraKeySpeed = DEFAULT_KEY_SPEED; + cameraSpeedModifier = DEFAULT_SPEED_MODIFIER; + cameraSensitivity = DEFAULT_SENSITIVITY; + stickDeadzone = DEFAULT_DEADZONE; + cameraPitchLimit = DEFAULT_PITCH_LIMIT; + } + ImGui.SameLine(); if (ImGui.Button("Reset")) { - cameraKeySpeed = 0.08f; - cameraSpeed = 0.55f; - cameraSensitivity = 0.112f; - stickDeadzone = 4500; + Config.Settings settings = config.CameraSettings; + cameraSpeed = settings.CameraSpeed; + cameraKeySpeed = settings.CameraKeySpeed; + cameraSpeedModifier = settings.CameraSpeedModifier; + cameraSensitivity = settings.CameraSensitivity; + stickDeadzone = settings.StickDeadzone; + cameraPitchLimit = settings.CameraPitchLimit; + } + ImGui.SameLine(); + if (ImGui.Button("Save")) + { + Config.Settings settings = config.CameraSettings; + settings.CameraSpeed = cameraSpeed; + settings.CameraKeySpeed = cameraKeySpeed; + settings.CameraSpeedModifier = cameraSpeedModifier; + settings.CameraSensitivity = cameraSensitivity; + settings.StickDeadzone = stickDeadzone; + settings.CameraPitchLimit = cameraPitchLimit; + config.CameraSettings = settings; + ConfigManager.SaveConfig(this); } ImGui.PopID(); @@ -370,12 +534,17 @@ namespace MHWNewCamera ImGui.Text($" Camera Pointer: {vp.Camera.Instance:x}"); ImGui.InputFloat("FOV", ref vp.Camera.FieldOfView); ImGui.Text($" Internal FOV: {previousFov}"); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("What the FOV would be if not set by us."); + ImGui.EndTooltip(); + } ImGui.InputFloat("Aspect Ratio", ref vp.Camera.AspectRatio); ImGui.InputFloat("Far Clip", ref vp.Camera.FarClip); ImGui.InputFloat("Near Clip", ref vp.Camera.NearClip); inputVector(ref vp.Camera.Position, "Position", "cam"); inputVector(ref vp.Camera.Target, "Target", "cam"); - inputVector(ref vp.Camera.Up, "Up", "cam"); + drawVector(vp.Camera.Up, "Up"); ImGui.Text(" Rotation:"); float pitch = cameraPitch; if (ImGui.InputFloat("Pitch", ref pitch, 0.0f, 0.0f, null, ImGuiInputTextFlags.EnterReturnsTrue)) @@ -392,10 +561,17 @@ namespace MHWNewCamera { cameraRoll = roll; } + float pitchLimit = cameraPitchLimit; + if (ImGui.InputFloat("Pitch Limit", ref pitchLimit, 0.0f, 0.0f, null, ImGuiInputTextFlags.EnterReturnsTrue)) + { + cameraPitchLimit = pitchLimit; + } ImGui.Text($" Move: {vp.Camera.Move}"); ImGui.Text($" Fix: {vp.Camera.Fix}"); } } + ImGui.Separator(); + ImGui.PushID("Pad"); ImGui.Text($"Pad:"); ImGui.Text($" Pointer: {sMhSteamController.Instance:x}"); int PadRx = MemoryUtil.Read(sMhSteamController.Instance + 0x1b0); @@ -404,8 +580,15 @@ namespace MHWNewCamera int PadLy = MemoryUtil.Read(sMhSteamController.Instance + 0x1bc); byte PadRz = MemoryUtil.Read(sMhSteamController.Instance + 0x1c0); byte PadLz = MemoryUtil.Read(sMhSteamController.Instance + 0x1c1); - ImGui.Text($" Left Stick: {PadLx} {PadLy} {PadLz}"); - ImGui.Text($" Right Stick: {PadRx} {PadRy} {PadRz}"); + ImGui.Text(" Left Stick:"); + ImGui.Text($" X: {PadLx}"); + ImGui.Text($" Y: {PadLy}"); + ImGui.Text($" L2: {PadLz}"); + ImGui.Text(" Right Stick:"); + ImGui.Text($" X: {PadRx}"); + ImGui.Text($" Y: {PadRy}"); + ImGui.Text($" R2: {PadRz}"); + ImGui.PopID(); ImGui.Separator(); ImGui.Text($"Player:"); Player? player = Player.MainPlayer; @@ -483,70 +666,70 @@ namespace MHWNewCamera float adjustedSpeed = cameraSpeed * deltaTime * 1000.0f; float adjustedSensitivity = cameraSensitivity * deltaTime * 1000.0f; - if (Input.IsPressed(binds.ToggleFreeCamera)) + if (keyboardEnabled) { - enableFreeCamera = !enableFreeCamera; - } + if (Input.IsPressed(keyboardBinds.ToggleFreeCamera)) + { + toggleFreeCamera = !toggleFreeCamera; + } - if (Input.IsPressed(binds.TogglePerspectiveCamera)) - { - enableOffsetPerspective = !enableOffsetPerspective; - } + if (Input.IsPressed(keyboardBinds.TogglePerspectiveCamera)) + { + toggleOffsetPerspective = !toggleOffsetPerspective; + } - if (Input.IsDown(binds.IncreaseSpeed)) - { - cameraSpeed += 0.5f * deltaTime; - } + /* + if (Input.IsDown(keyboardBinds.IncreaseSpeed)) + { + cameraSpeed += 0.5f * deltaTime; + } - if (Input.IsDown(binds.DecreaseSpeed)) - { - cameraSpeed -= 0.5f * deltaTime; - if (cameraSpeed < 0.1f) cameraSpeed = 0.1f; - } + if (Input.IsDown(keyboardBinds.DecreaseSpeed)) + { + cameraSpeed -= 0.5f * deltaTime; + if (cameraSpeed < 0.1f) cameraSpeed = 0.1f; + } - if (!(Input.IsDown(Key.RightControl) || Input.IsDown(Key.LeftControl))) - { - if (Input.IsDown(binds.IncreaseFOV)) + if (Input.IsDown(keyboardBinds.IncreaseFOV)) { - cameraFov += adjustedKeySpeed / 2.0f; + cameraFov += adjustedKeySpeed; } - if (Input.IsDown(binds.DecreaseFOV)) + if (Input.IsDown(keyboardBinds.DecreaseFOV)) { - cameraFov -= adjustedKeySpeed / 2.0f; + cameraFov -= adjustedKeySpeed; } - if (Input.IsDown(binds.Forward)) + if (Input.IsDown(keyboardBinds.Forward)) { cameraForward += adjustedKeySpeed; } - if (Input.IsDown(binds.Backward)) + if (Input.IsDown(keyboardBinds.Backward)) { cameraForward -= adjustedKeySpeed; } - if (Input.IsDown(binds.Left)) + if (Input.IsDown(keyboardBinds.Left)) { cameraLeft += adjustedKeySpeed; } - if (Input.IsDown(binds.Right)) + if (Input.IsDown(keyboardBinds.Right)) { cameraLeft -= adjustedKeySpeed; } - } - else - { - if (Input.IsDown(binds.Up)) + + if (Input.IsDown(keyboardBinds.Up)) { cameraYOffset += adjustedKeySpeed; } - if (Input.IsDown(binds.Down)) + if (Input.IsDown(keyboardBinds.Down)) { cameraYOffset -= adjustedKeySpeed; } + */ } Viewport vp = CameraSystem.MainViewport; @@ -554,85 +737,76 @@ namespace MHWNewCamera if (camera == null) return; Player? player = Player.MainPlayer; - if (enableOffsetPerspective && !offsetPerspective) - { - offsetPerspective = true; - targetCamera = camera; - } - else if (!enableOffsetPerspective && offsetPerspective) + if (player != null) { - offsetPerspective = false; + if (toggleOffsetPerspective && !offsetPerspective) + { + offsetPerspective = true; + targetCamera = camera; + previousFov = -1.0f; + } + else if (!toggleOffsetPerspective && offsetPerspective) + { + offsetPerspective = false; + targetCamera = null; + } } - if (!offsetPerspective) + if (Input.IsDown(Button.L2) && Input.IsPressed(Button.L1)) { - targetCamera = camera; + toggleFreeCamera = !toggleFreeCamera; } - if (!enableFreeCamera && freeCamera) + if (!toggleFreeCamera && freeCamera) { freeCamera = false; camera.Move = true; - /* - if (player != null && (movementFreezeHeld || movementFreezeToggled)) - { - player.Move = true; - } - */ } if (freeCamera) { if (player != null) { - if (!movementFreezeHeld && Input.IsPressed(Button.R1)) + if (!unlockMovementHeld && Input.IsPressed(Button.L1)) { - //player.Move = !player.Move; - //movementFreezeToggled = !player.Move; - movementFreezeToggled = !movementFreezeToggled; + unlockMovementToggled = !unlockMovementToggled; } - if (!movementFreezeToggled) + if (!unlockMovementToggled) { if (Input.IsPressed(Button.R2)) { - //player.Move = false; - movementFreezeHeld = true; + unlockMovementHeld = true; } if (Input.IsReleased(Button.R2)) { - //player.Move = true; - movementFreezeHeld = false; + unlockMovementHeld = false; } } } - if (!(movementFreezeHeld || movementFreezeToggled)) + if (!(unlockMovementHeld || unlockMovementToggled)) { int PadLx = MemoryUtil.Read(sMhSteamController.Instance + 0x1b8); if (Math.Abs(PadLx) < stickDeadzone) PadLx = 0; int PadLy = MemoryUtil.Read(sMhSteamController.Instance + 0x1bc); if (Math.Abs(PadLy) < stickDeadzone) PadLy = 0; - float Lx = (PadLx / (Int16.MaxValue / adjustedSpeed)); - float Ly = (PadLy / (Int16.MaxValue / adjustedSpeed)); - Quaternion forward = Quaternion.Normalize(new Quaternion( - camera.Target.X - camera.Position.X, - camera.Target.Y - camera.Position.Y, - camera.Target.Z - camera.Position.Z, - 0.0f)); + float Lx = PadLx / (Int16.MaxValue / adjustedSpeed); + float Ly = PadLy / (Int16.MaxValue / adjustedSpeed); + Quaternion forward = getForward(camera.Position, camera.Target); if (Input.IsDown(Button.L2)) { if (Input.IsDown(Button.Down)) { - camera.Position.Y -= adjustedKeySpeed; + camera.Position.Y -= adjustedKeySpeed * cameraSpeedModifier; } if (Input.IsDown(Button.Up)) { - camera.Position.Y += adjustedKeySpeed; + camera.Position.Y += adjustedKeySpeed * cameraSpeedModifier; } - Lx /= 3.0f; - Ly /= 3.0f; + Lx *= cameraSpeedModifier; + Ly *= cameraSpeedModifier; forward.Y = 0.0f; } forward = Quaternion.Normalize(forward); @@ -643,7 +817,6 @@ namespace MHWNewCamera camera.Position.Y += forward.Y * Ly; camera.Position.Z += forward.Z * Ly; } - int PadRx = MemoryUtil.Read(sMhSteamController.Instance + 0x1b0); if (Math.Abs(PadRx) < stickDeadzone) PadRx = 0; int PadRy = MemoryUtil.Read(sMhSteamController.Instance + 0x1b4); @@ -652,9 +825,9 @@ namespace MHWNewCamera float Ry = PadRy / (Int16.MaxValue / adjustedSensitivity); cameraYaw += Rx; cameraPitch += Ry; - float cap = 89.5f; - if(cameraPitch > cap) cameraPitch = cap; - if(cameraPitch < -cap) cameraPitch = -cap; + float cap = cameraPitchLimit; + if (cameraPitch > cap) cameraPitch = cap; + else if (cameraPitch < -cap) cameraPitch = -cap; camera.Target.X = camera.Position.X + ((float)Math.Cos(Single.DegreesToRadians(cameraPitch)) * (float)Math.Cos(Single.DegreesToRadians(cameraYaw))); camera.Target.Y = camera.Position.Y + (float)Math.Sin(Single.DegreesToRadians(cameraPitch)); camera.Target.Z = camera.Position.Z + ((float)Math.Cos(Single.DegreesToRadians(cameraPitch)) * (float)Math.Sin(Single.DegreesToRadians(cameraYaw))); -- cgit v1.2.3-101-g0448