summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-xConfig.cs81
-rwxr-xr-xMHWNewCamera.csproj2
-rwxr-xr-xPlugin.cs495
3 files changed, 416 insertions, 162 deletions
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<string, Preset> Presets { get; set; } = new Dictionary<string, Preset>();
+ 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 @@
</PropertyGroup>
<ItemGroup>
- <PackageReference Include="SharpPluginLoader.Core" Version="0.0.7" />
+ <PackageReference Include="SharpPluginLoader.Core" Version="0.0.7.2" />
<PackageReference Include="SharpPluginLoader.ImGui" Version="1.90.2.3" />
</ItemGroup>
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<CalculateCameraDelegate>? 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<Config>(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<Config>(this);
// Hook where we can adjust the camera position.
calculateCameraHook = Hook.Create<CalculateCameraDelegate>(0x141fa5380, CalculateCameraHook);
-
//calculateCameraHook = Hook.Create<CalculateCameraDelegate>(0x142290620, CalculateCameraHook);
+
// Hook where we can directly modify the view matrix.
calculateViewHook = Hook.Create<CalculateViewDelegate>(0x14228eb60, CalculateViewHook);
//calculateViewHook2 = Hook.Create<CalculateViewDelegate>(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;
+
+ decreasingFov = previousFov >= 0.0f && previousFov > camera.FieldOfView;
- 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));
+ bool applyPerspective = camera.Fix && camera.Move;
+ applyPerspective &= !assumeInQuestBoard(camera.FieldOfView);
+ applyPerspective &= !(assumeInAnimation(vp, camera) && decreasingFov);
+ applyPerspective &= !assumeInOpenMapAnimation(camera.FieldOfView);
+ applyPerspective &= !assumeInCanteen(camera.FieldOfView, previousFov);
- decreasingFov = previousFov >= 0.0f && previousFov > camera.FieldOfView;
- previousFov = camera.FieldOfView;
+ previousFov = camera.FieldOfView;
- if ((offsetPerspective && !freeCamera) && camera.Fix && camera.Move &&
- !assumeInQuestBoard(camera.FieldOfView) && !(assumeInAnimation(vp, camera) && decreasingFov) &&
- !assumeInOpenMapAnimation(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<Config>(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<Config>(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<Config>(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<Config>(this);
+ }
}
+ ImGui.SameLine();
+ ImGui.PushItemWidth(170);
+ ImGui.InputText("##Preset Name", ref typedPresetName, 99);
+ ImGui.SameLine();
+ if (ImGui.BeginCombo("##Preset", config.Selected))
+ {
+ Dictionary<string, Config.Preset>.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<Config>(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("Rate of camera adjustment buttons/keybinds.");
+ ImGui.EndTooltip();
+ }
+ ImGui.SliderFloat("Speed Modifier", ref cameraSpeedModifier, 0.1f, 10.0f);
if (ImGui.BeginItemTooltip())
{
- ImGui.Text("Camera Movement in Free Camera");
+ 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<Config>(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<int>(sMhSteamController.Instance + 0x1b0);
@@ -404,8 +580,15 @@ namespace MHWNewCamera
int PadLy = MemoryUtil.Read<int>(sMhSteamController.Instance + 0x1bc);
byte PadRz = MemoryUtil.Read<byte>(sMhSteamController.Instance + 0x1c0);
byte PadLz = MemoryUtil.Read<byte>(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<int>(sMhSteamController.Instance + 0x1b8);
if (Math.Abs(PadLx) < stickDeadzone) PadLx = 0;
int PadLy = MemoryUtil.Read<int>(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<int>(sMhSteamController.Instance + 0x1b0);
if (Math.Abs(PadRx) < stickDeadzone) PadRx = 0;
int PadRy = MemoryUtil.Read<int>(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)));
generated by cgit v1.2.3-101-g0448 (git 2.54.0) at 2026-07-25 19:22:12 +0000