Revert to single precision floats, use MathF

Signed-off-by: Andrew Opalach <andrew@akon.city>

2 files changed, 127 insertions, 150 deletions

diff --git a/Config.cs b/Config.cs
index cea23cb..43f2cca 100755
--- a/Config.cs
+++ b/Config.cs
@@ -8,7 +8,7 @@ namespace MHWNewCamera
     internal class Config : IConfig

     {

         public String Name => "MHWNewCamera";

-        public String Version => "4.0";

+        public String Version => "4.1";

 

         public struct Settings

         {

@@ -16,8 +16,8 @@ namespace MHWNewCamera
             public const float DEFAULT_SPEED_MODIFIER = 0.40f;

             public const float DEFAULT_SENSITIVITY = 0.0425f;

             public const float DEFAULT_ZOOM_SPEED = 0.02f;

-            public const double DEFAULT_PITCH_LIMIT = -1.0;

-            public const double MAX_PITCH_LIMIT = 89.95;

+            public const float DEFAULT_PITCH_LIMIT = -1.0f;

+            public const float MAX_PITCH_LIMIT = 89.95f;

             public const int DEFAULT_DEADZONE = 4750;

             public const float DEFAULT_ALT_NEAR_CLIP = 0.3f;

 

@@ -36,7 +36,7 @@ namespace MHWNewCamera
             public float SpeedModifier { get; set; }

             public float Sensitivity { get; set; }

             public float ZoomSpeed { get; set; }

-            public double PitchLimit { get; set; }

+            public float PitchLimit { get; set; }

             public int StickDeadzone { get; set; }

             public float AlternateNearClip { get; set; }

 

@@ -63,11 +63,11 @@ namespace MHWNewCamera
 

         public struct Preset

         {

-            public double FieldOfView { get; set; }

+            public float FieldOfView { get; set; }

             public float Forward { get; set; }

             public float Right { get; set; }

             public float Up { get; set; }

-            public double Roll { get; set; }

+            public float Roll { get; set; }

             public bool DisableFading { get; set; }

         }

 

@@ -122,7 +122,7 @@ namespace MHWNewCamera
             public float TargetX { get; set; }

             public float TargetY { get; set; }

             public float TargetZ { get; set; }

-            public double Roll { get; set; }

+            public float Roll { get; set; }

         }

 

         private static Dictionary<string, Button> buttonMap = new Dictionary<string, Button>

diff --git a/Plugin.cs b/Plugin.cs
index 8f23d00..787025a 100755
--- a/Plugin.cs
+++ b/Plugin.cs
@@ -45,7 +45,6 @@ using SharpPluginLoader.Core.Configuration;
 //  - Open Poses Menu

 

 // @TODO:

-//  - Float conversion.

 //  - Use GetRef<>.

 //  - Hide Hunter's Knife/Slinger.

 //  - General "A/B Graphical Settings" function.

@@ -184,7 +183,7 @@ namespace MHWNewCamera
         public string Name => "MHW New Camera";

         public string Author => "Akon City Software";

 

-        private const double DEFAULT_FOV = 60.0;

+        private const float DEFAULT_FOV = 60.0f;

         private const float DEFAULT_NEAR_CLIP = 16.0f;

 

         private static byte byteFlag(bool f) { return f ? (byte)0x1 : (byte)0x0; }

@@ -198,19 +197,19 @@ namespace MHWNewCamera
         private float cameraSpeedModifier;

         private float cameraSensitivity;

         private float cameraZoomSpeed;

-        private double cameraPitchLimit;

+        private float cameraPitchLimit;

         private int stickDeadzone;

         private float alternateNearClip;

 

-        private double cameraFov = DEFAULT_FOV;

+        private float cameraFov = DEFAULT_FOV;

         private float cameraForward = 0.0f;

         private float cameraRight = 0.0f;

         private float cameraXOffset = 0.0f;

         private float cameraYOffset = 0.0f;

         private float cameraZOffset = 0.0f;

-        private double cameraYaw = 0.0;

-        private double cameraPitch = 0.0;

-        private double cameraRoll = 0.0;

+        private float cameraYaw = 0.0f;

+        private float cameraPitch = 0.0f;

+        private float cameraRoll = 0.0f;

         private bool disableFading = false;

         private int cameraWrapState = 0;

 

@@ -220,14 +219,12 @@ namespace MHWNewCamera
         private bool freeCameraFallback = false;

         private Camera? vCamera = null;

         private int vCameraViewportIndex = -1;

-        private double? restoreFov = null;

-        private double? restoreRoll = null;

+        private float? restoreFov = null;

+        private float? restoreRoll = null;

         private float? restoreNearClip = null;

         private Vector3 cameraPosition;

         private Vector3 cameraTarget;

-        private double cameraFrameX;

-        private double cameraFrameY;

-        private double cameraFrameZ;

+        private Vector3 cameraFrame;

         private bool unlockMovementHeld = false;

         private bool unlockMovementToggled = false;

         private bool unlockMovementPause = false;

@@ -632,9 +629,9 @@ namespace MHWNewCamera
             cameraSensitivity = camera.Sensitivity;

             cameraZoomSpeed = camera.ZoomSpeed;

             cameraPitchLimit = camera.PitchLimit;

-            if (cameraPitchLimit != -1.0)

+            if (cameraPitchLimit != -1.0f)

             {

-                cameraPitchLimit = Math.Clamp(cameraPitchLimit, 0.0, Config.Settings.MAX_PITCH_LIMIT);

+                cameraPitchLimit = Math.Clamp(cameraPitchLimit, 0.0f, Config.Settings.MAX_PITCH_LIMIT);

             }

             stickDeadzone = camera.StickDeadzone;

             alternateNearClip = camera.AlternateNearClip;

@@ -1207,8 +1204,8 @@ namespace MHWNewCamera
                     if (!freeCamera)

                     {

                         Quaternion forward = Quaternion.Normalize(getForward(vCamera.Position, vCamera.Target));

-                        cameraYaw = Double.RadiansToDegrees(Math.Atan2(forward.Z, forward.X));

-                        cameraPitch = Double.RadiansToDegrees(Math.Asin(forward.Y));

+                        cameraYaw = Single.RadiansToDegrees(MathF.Atan2(forward.Z, forward.X));

+                        cameraPitch = Single.RadiansToDegrees(MathF.Asin(forward.Y));

                         if (enableFreeCamera)

                         {

                             setupFreeCamera(vCamera, vCameraViewportIndex);

@@ -1256,24 +1253,24 @@ namespace MHWNewCamera
 

         private static Quaternion getRight(Quaternion q)

         {

-            return q * Quaternion.CreateFromYawPitchRoll((float)Math.PI, 0.0f, 0.0f);

+            return q * Quaternion.CreateFromYawPitchRoll(MathF.PI, 0.0f, 0.0f);

         }

 

         private static Quaternion getReverse(Quaternion q)

         {

-            return q * Quaternion.CreateFromYawPitchRoll((float)Math.PI, 0.0f, 0.0f);

+            return q * Quaternion.CreateFromYawPitchRoll(MathF.PI, 0.0f, 0.0f);

         }

 

         private void setCameraRoll(Camera camera)

         {

             // Don't test our luck with precision weirdness if we know we can be exact.

-            if (cameraRoll == 0.0)

+            if (cameraRoll == 0.0f)

             {

                 camera.Up.X = 0.0f;

                 camera.Up.Y = 1.0f;

                 camera.Up.Z = 0.0f;

             }

-            else if (cameraRoll == 180.0)

+            else if (cameraRoll == 180.0f)

             {

                 camera.Up.X = 0.0f;

                 camera.Up.Y = -1.0f;

@@ -1282,9 +1279,9 @@ namespace MHWNewCamera
             else

             {

                 // yaw + 90.0 = point right.

-                camera.Up.X = (float)(Math.Sin(Double.DegreesToRadians(cameraRoll)) * Math.Cos(Double.DegreesToRadians(cameraPitch)) * Math.Cos(Double.DegreesToRadians(cameraYaw + 90.0)));

-                camera.Up.Y = (float)(Math.Cos(Double.DegreesToRadians(cameraRoll)));

-                camera.Up.Z = (float)(Math.Sin(Double.DegreesToRadians(cameraRoll)) * Math.Cos(Double.DegreesToRadians(cameraPitch)) * Math.Sin(Double.DegreesToRadians(cameraYaw + 90.0)));

+                camera.Up.X = MathF.Sin(Single.DegreesToRadians(cameraRoll)) * MathF.Cos(Single.DegreesToRadians(cameraPitch)) * MathF.Cos(Single.DegreesToRadians(cameraYaw + 90.0f));

+                camera.Up.Y = MathF.Cos(Single.DegreesToRadians(cameraRoll));

+                camera.Up.Z = MathF.Sin(Single.DegreesToRadians(cameraRoll)) * MathF.Cos(Single.DegreesToRadians(cameraPitch)) * MathF.Sin(Single.DegreesToRadians(cameraYaw + 90.0f));

             }

         }

 

@@ -1339,7 +1336,7 @@ namespace MHWNewCamera
             camera.Position = pos;

             if (cameraFov != DEFAULT_FOV)

             {

-                camera.FieldOfView = (float)Math.Clamp((cameraFov * previousFov) / DEFAULT_FOV, 1.0, 179.0);

+                camera.FieldOfView = Math.Clamp((cameraFov * previousFov) / DEFAULT_FOV, 1.0f, 179.0f);

             }

         }

 

@@ -1391,12 +1388,12 @@ namespace MHWNewCamera
             unlockInputHideMenu = false;

             if (restoreFov != null)

             {

-                cameraFov = (double)restoreFov;

+                cameraFov = (float)restoreFov;

                 restoreFov = null;

             }

             if (restoreRoll != null)

             {

-                cameraRoll = (double)restoreRoll;

+                cameraRoll = (float)restoreRoll;

                 restoreRoll = null;

             }

             if (restoreNearClip != null && vCamera != null)

@@ -1412,7 +1409,7 @@ namespace MHWNewCamera
             //stopViewMode.Invoke(psuedoViewModeObject);

         }

 

-        private double adjustedZoomSpeed(float deltaTime)

+        private float adjustedZoomSpeed(float deltaTime)

         {

             return cameraZoomSpeed * deltaTime * cameraFov;

         }

@@ -1430,18 +1427,18 @@ namespace MHWNewCamera
             }

 

             bool lockVerticalAndModifySpeed = buttonWasDown(Button.L2) || lockVerticalToggled;

-            double adjustedSpeed = cameraSpeed * deltaTime * (lockVerticalAndModifySpeed ? cameraSpeedModifier : 1.0f);

+            float adjustedSpeed = cameraSpeed * deltaTime * (lockVerticalAndModifySpeed ? cameraSpeedModifier : 1.0f);

 

-            cameraFrameX = 0.0;

-            cameraFrameY = 0.0;

-            cameraFrameZ = 0.0;

+            cameraFrame.X = 0.0f;

+            cameraFrame.Y = 0.0f;

+            cameraFrame.Z = 0.0f;

 

             // PadLx/y is read in WritePadInputHook().

             if (buttonWasDown(Button.L2) && buttonWasDown(Button.R2)) // Left stick zoom.

             {

                 if (Math.Abs(PadLy) < stickDeadzone) PadLy = 0;

-                double Ly = PadLy / (Int16.MaxValue / adjustedZoomSpeed(deltaTime));

-                cameraFov = Math.Clamp(cameraFov - Ly, 1.0, 179.0);

+                float Ly = PadLy / (Int16.MaxValue / adjustedZoomSpeed(deltaTime));

+                cameraFov = Math.Clamp(cameraFov - Ly, 1.0f, 179.0f);

             }

             else if (playerMovementLocked || orbitPlayer) // Move camera.

             {

@@ -1456,20 +1453,20 @@ namespace MHWNewCamera
                     if (Input.IsDown(Key.Right)) PadLx += Int16.MaxValue;

                 }

 #endif

-                double Ly = PadLy / (Int16.MaxValue / adjustedSpeed);

-                double Lx = PadLx / (Int16.MaxValue / adjustedSpeed);

+                float Ly = PadLy / (Int16.MaxValue / adjustedSpeed);

+                float Lx = PadLx / (Int16.MaxValue / adjustedSpeed);

 

                 if (orbitPlayer)

                 {

                     if (playerMovementLocked)

                     {

-                        orbitForward -= (float)Ly;

+                        orbitForward -= Ly;

                         if (orbitForward < 0.01f)

                         {

                             orbitForward = 0.01f;

                         }

                     }

-                    orbitMovementRotation += (float)(Lx / 5.0);

+                    orbitMovementRotation += Lx / 5.0f;

                     if (orbitMovementRotation >= 180.0f)

                     {

                         orbitMovementRotation -= 360.0f;

@@ -1497,16 +1494,16 @@ namespace MHWNewCamera
                     right = getRight(right);

                     forward = Quaternion.Normalize(forward);

                     right = Quaternion.Normalize(right);

-                    cameraFrameX += right.X * Lx;

-                    cameraFrameZ += right.Z * Lx;

-                    cameraFrameX += forward.X * Ly;

-                    cameraFrameY += forward.Y * Ly;

-                    cameraFrameZ += forward.Z * Ly;

+                    cameraFrame.X += right.X * Lx;

+                    cameraFrame.Z += right.Z * Lx;

+                    cameraFrame.X += forward.X * Ly;

+                    cameraFrame.Y += forward.Y * Ly;

+                    cameraFrame.Z += forward.Z * Ly;

                     if (plusForward != 0.0f)

                     {

-                        cameraFrameX += forward.X * plusForward * deltaTime;

-                        cameraFrameY += forward.Y * plusForward * deltaTime;

-                        cameraFrameZ += forward.Z * plusForward * deltaTime;

+                        cameraFrame.X += forward.X * plusForward * deltaTime;

+                        cameraFrame.Y += forward.Y * plusForward * deltaTime;

+                        cameraFrame.Z += forward.Z * plusForward * deltaTime;

                     }

                 }

             }

@@ -1524,13 +1521,13 @@ namespace MHWNewCamera
                 {

                     if (buttonWasPressed(Button.Right))

                     {

-                        cameraRoll = (restoreRoll != null) ? (double)restoreRoll : 0.0;

+                        cameraRoll = (restoreRoll != null) ? (float)restoreRoll : 0.0f;

                     }

                     if (buttonWasPressed(Button.Up))

                     {

                         if (restoreFov != null)

                         {

-                            cameraFov = (float)Math.Clamp((double)restoreFov * (previousFov / DEFAULT_FOV), 1.0, 179.0);

+                            cameraFov = Math.Clamp((float)restoreFov * (previousFov / DEFAULT_FOV), 1.0f, 179.0f);

                         }

                         else

                         {

@@ -1544,31 +1541,31 @@ namespace MHWNewCamera
                     {

                         if (orbitPlayer)

                         {

-                            orbitY += (float)(adjustedSpeed / 2.0);

+                            orbitY += adjustedSpeed / 2.0f;

                         }

                         else

                         {

-                            cameraFrameY += adjustedSpeed / 2.0;

+                            cameraFrame.Y += adjustedSpeed / 2.0f;

                         }

                     }

                     if (buttonWasDown(Button.Down))

                     {

                         if (orbitPlayer)

                         {

-                            orbitY -= (float)(adjustedSpeed / 2.0);

+                            orbitY -= adjustedSpeed / 2.0f;

                         }

                         else

                         {

-                            cameraFrameY -= adjustedSpeed / 2.0;

+                            cameraFrame.Y -= adjustedSpeed / 2.0f;

                         }

                     }

                     if (buttonWasDown(Button.Left))

                     {

-                        cameraRoll -= adjustedSpeed / 4.0;

+                        cameraRoll -= adjustedSpeed / 4.0f;

                     }

                     if (buttonWasDown(Button.Right))

                     {

-                        cameraRoll += adjustedSpeed / 4.0;

+                        cameraRoll += adjustedSpeed / 4.0f;

                     }

                 }

             }

@@ -1578,31 +1575,31 @@ namespace MHWNewCamera
             {

                 if (Input.IsDown(Key.NumPadMinus))

                 {

-                    cameraFov = Math.Clamp(cameraFov - adjustedZoomSpeed(deltaTime), 1.0, 179.0);

+                    cameraFov = Math.Clamp(cameraFov - adjustedZoomSpeed(deltaTime), 1.0f, 179.0f);

                 }

                 if (Input.IsDown(Key.NumPadPlus))

                 {

-                    cameraFov = Math.Clamp(cameraFov + adjustedZoomSpeed(deltaTime), 1.0, 179.0);

+                    cameraFov = Math.Clamp(cameraFov + adjustedZoomSpeed(deltaTime), 1.0f, 179.0f);

                 }

                 if (Input.IsPressed(Key.NumPadStar))

                 {

-                    cameraRoll = (restoreRoll != null) ? (double)restoreRoll : 0.0f;

+                    cameraRoll = (restoreRoll != null) ? (float)restoreRoll : 0.0f;

                 }

                 if (Input.IsDown(Key.NumPad7))

                 {

-                    cameraFrameY += adjustedSpeed / 2.0;

+                    cameraFrame.Y += adjustedSpeed / 2.0f;

                 }

                 if (Input.IsDown(Key.NumPad1))

                 {

-                    cameraFrameY -= adjustedSpeed / 2.0;

+                    cameraFrame.Y -= adjustedSpeed / 2.0f;

                 }

                 if (Input.IsDown(Key.NumPad9))

                 {

-                    cameraRoll += adjustedSpeed / 4.0;

+                    cameraRoll += adjustedSpeed / 4.0f;

                 }

                 if (Input.IsDown(Key.NumPad3))

                 {

-                    cameraRoll -= adjustedSpeed / 4.0;

+                    cameraRoll -= adjustedSpeed / 4.0f;

                 }

             }

 #endif

@@ -1619,59 +1616,59 @@ namespace MHWNewCamera
                 if (Input.IsDown(Key.NumPad6)) PadRx += keyboardLookValue;

             }

 #endif

-            double adjustedSensitivity = cameraSensitivity * deltaTime * cameraFov;

-            double Rx = PadRx / (Int16.MaxValue / adjustedSensitivity);

-            double Ry = PadRy / (Int16.MaxValue / adjustedSensitivity);

+            float adjustedSensitivity = cameraSensitivity * deltaTime * cameraFov;

+            float Rx = PadRx / (Int16.MaxValue / adjustedSensitivity);

+            float Ry = PadRy / (Int16.MaxValue / adjustedSensitivity);

             cameraYaw += Rx;

             if (plusRight != 0.0f)

             {

                 cameraYaw += plusRight * deltaTime;

             }

-            if (cameraYaw >= 180.0)

+            if (cameraYaw >= 180.0f)

             {

-                cameraYaw -= 360.0;

+                cameraYaw -= 360.0f;

             }

-            else if (cameraYaw < -180.0)

+            else if (cameraYaw < -180.0f)

             {

-                cameraYaw += 360.0;

+                cameraYaw += 360.0f;

             }

-            if (cameraPitchLimit >= 0.0)

+            if (cameraPitchLimit >= 0.0f)

             {

                 cameraPitch = Math.Clamp(cameraPitch + Ry, -cameraPitchLimit, cameraPitchLimit);

             }

             else

             {

                 cameraPitch += Ry;

-                if (cameraPitch >= 90.0 && cameraWrapState == 0)

+                if (cameraPitch >= 90.0f && cameraWrapState == 0)

                 {

-                    cameraRoll += 180.0;

+                    cameraRoll += 180.0f;

                     cameraWrapState = 1;

                 }

-                else if (cameraPitch < -90.0 && cameraWrapState == 0)

+                else if (cameraPitch < -90.0f && cameraWrapState == 0)

                 {

-                    cameraPitch += 360.0;

-                    cameraRoll += 180.0;

+                    cameraPitch += 360.0f;

+                    cameraRoll += 180.0f;

                     cameraWrapState = 1;

                 }

-                else if (cameraPitch < 90.0 && cameraWrapState == 1)

+                else if (cameraPitch < 90.0f && cameraWrapState == 1)

                 {

-                    cameraRoll -= 180.0;

+                    cameraRoll -= 180.0f;

                     cameraWrapState = 0;

                 }

-                else if (cameraPitch >= 270.0 && cameraWrapState == 1)

+                else if (cameraPitch >= 270.0f && cameraWrapState == 1)

                 {

-                    cameraPitch -= 360.0;

-                    cameraRoll -= 180.0;

+                    cameraPitch -= 360.0f;

+                    cameraRoll -= 180.0f;

                     cameraWrapState = 0;

                 }

             }

-            if (cameraRoll < 0.0)

+            if (cameraRoll < 0.0f)

             {

-                cameraRoll += 360.0;

+                cameraRoll += 360.0f;

             }

-            else if (cameraRoll >= 360.0)

+            else if (cameraRoll >= 360.0f)

             {

-                cameraRoll -= 360.0;

+                cameraRoll -= 360.0f;

             }

 

             Player? player = Player.MainPlayer;

@@ -1681,30 +1678,30 @@ namespace MHWNewCamera
                 Quaternion rotation = new Quaternion(player.Rotation.X, player.Rotation.Y, player.Rotation.Z, player.Rotation.W);

                 up = Vector3.Transform(up, rotation);

                 cameraTarget = player.Position;

-                cameraTarget.X += (float)(orbitY * up.X);

-                cameraTarget.Y += (float)(orbitY * up.Y);

-                cameraTarget.Z += (float)(orbitY * up.Z);

-                double dist = orbitForward;

-                cameraPosition.X = cameraTarget.X - (float)(dist * Math.Cos(Double.DegreesToRadians(cameraPitch)) * Math.Cos(Double.DegreesToRadians(cameraYaw)));

-                cameraPosition.Y = cameraTarget.Y - (float)(dist * Math.Sin(Double.DegreesToRadians(cameraPitch)));

-                cameraPosition.Z = cameraTarget.Z - (float)(dist * Math.Cos(Double.DegreesToRadians(cameraPitch)) * Math.Sin(Double.DegreesToRadians(cameraYaw)));

+                cameraTarget.X += orbitY * up.X;

+                cameraTarget.Y += orbitY * up.Y;

+                cameraTarget.Z += orbitY * up.Z;

+                float dist = orbitForward;

+                cameraPosition.X = cameraTarget.X - dist * MathF.Cos(Single.DegreesToRadians(cameraPitch)) * MathF.Cos(Single.DegreesToRadians(cameraYaw));

+                cameraPosition.Y = cameraTarget.Y - dist * MathF.Sin(Single.DegreesToRadians(cameraPitch));

+                cameraPosition.Z = cameraTarget.Z - dist * MathF.Cos(Single.DegreesToRadians(cameraPitch)) * MathF.Sin(Single.DegreesToRadians(cameraYaw));

             }

             else

             {

-                cameraPosition.X += (float)cameraFrameX;

-                cameraPosition.Y += (float)cameraFrameY;

-                cameraPosition.Z += (float)cameraFrameZ;

+                cameraPosition.X += cameraFrame.X;

+                cameraPosition.Y += cameraFrame.Y;

+                cameraPosition.Z += cameraFrame.Z;

                 // 700.0 is the same value the game uses for the player camera. The in-game view mode

                 // uses 1.0 like I did here before, which is really bad for precision.

-                double dist = 700.0 - cameraForward;

-                cameraTarget.X = cameraPosition.X + (float)(dist * Math.Cos(Double.DegreesToRadians(cameraPitch)) * Math.Cos(Double.DegreesToRadians(cameraYaw)));

-                cameraTarget.Y = cameraPosition.Y + (float)(dist * Math.Sin(Double.DegreesToRadians(cameraPitch)));

-                cameraTarget.Z = cameraPosition.Z + (float)(dist * Math.Cos(Double.DegreesToRadians(cameraPitch)) * Math.Sin(Double.DegreesToRadians(cameraYaw)));

+                float dist = 700.0f - cameraForward;

+                cameraTarget.X = cameraPosition.X + dist * MathF.Cos(Single.DegreesToRadians(cameraPitch)) * MathF.Cos(Single.DegreesToRadians(cameraYaw));

+                cameraTarget.Y = cameraPosition.Y + dist * MathF.Sin(Single.DegreesToRadians(cameraPitch));

+                cameraTarget.Z = cameraPosition.Z + dist * MathF.Cos(Single.DegreesToRadians(cameraPitch)) * MathF.Sin(Single.DegreesToRadians(cameraYaw));

             }

 

             camera.Position = cameraPosition;

             camera.Target = cameraTarget;

-            camera.FieldOfView = (float)cameraFov;

+            camera.FieldOfView = cameraFov;

         }

 

         private Player? checkPlayerChange()

@@ -1769,8 +1766,8 @@ namespace MHWNewCamera
                             cameraTarget = camera.Target;

                         }

                         Quaternion forward = Quaternion.Normalize(getForward(cameraPosition, cameraTarget));

-                        cameraYaw = Double.RadiansToDegrees(Math.Atan2(forward.Z, forward.X));

-                        cameraPitch = Double.RadiansToDegrees(Math.Asin(forward.Y));

+                        cameraYaw = Single.RadiansToDegrees(MathF.Atan2(forward.Z, forward.X));

+                        cameraPitch = Single.RadiansToDegrees(MathF.Asin(forward.Y));

                     }

                 }

                 vCamera = camera;

@@ -1912,7 +1909,7 @@ namespace MHWNewCamera
 

             if (perspectiveFovOnly && cameraFov != DEFAULT_FOV)

             {

-                pCamera!.FieldOfView = (float)Math.Clamp((cameraFov * previousFov) / DEFAULT_FOV, 1.0, 179.0);

+                pCamera!.FieldOfView = Math.Clamp((cameraFov * previousFov) / DEFAULT_FOV, 1.0f, 179.0f);

             }

 

             calculateCameraHook!.Original(cameraPointer);

@@ -1933,8 +1930,8 @@ namespace MHWNewCamera
                     // We need pitch and yaw to apply cameraRoll and avoid a jump if applyPerspective = false.

                     // @TODO: These values could just be read from the in-game camera.

                     Quaternion forward = Quaternion.Normalize(getForward(vCamera.Position, vCamera.Target));

-                    cameraYaw = Double.RadiansToDegrees(Math.Atan2(forward.Z, forward.X));

-                    cameraPitch = Double.RadiansToDegrees(Math.Asin(forward.Y));

+                    cameraYaw = Single.RadiansToDegrees(MathF.Atan2(forward.Z, forward.X));

+                    cameraPitch = Single.RadiansToDegrees(MathF.Asin(forward.Y));

                     if (enableFreeCamera)

                     {

                         setupFreeCamera(vCamera, vCameraViewportIndex);

@@ -1969,9 +1966,9 @@ namespace MHWNewCamera
             {

                 updateFreeCamera(vCamera);

 

-                MemoryUtil.WriteBytes(psuedoViewModeObject + 0xE0, BitConverter.GetBytes((float)cameraFrameX));

-                MemoryUtil.WriteBytes(psuedoViewModeObject + 0xE4, BitConverter.GetBytes((float)cameraFrameY));

-                MemoryUtil.WriteBytes(psuedoViewModeObject + 0xE8, BitConverter.GetBytes((float)cameraFrameZ));

+                MemoryUtil.WriteBytes(psuedoViewModeObject + 0xE0, BitConverter.GetBytes(cameraFrame.X));

+                MemoryUtil.WriteBytes(psuedoViewModeObject + 0xE4, BitConverter.GetBytes(cameraFrame.Y));

+                MemoryUtil.WriteBytes(psuedoViewModeObject + 0xE8, BitConverter.GetBytes(cameraFrame.Z));

 

                 processViewMode.Invoke(psuedoViewModeObject);

 

@@ -2030,7 +2027,7 @@ namespace MHWNewCamera
             {

                 vCamera.Position = cameraPosition;

                 vCamera.Target = cameraTarget;

-                vCamera.FieldOfView = (float)cameraFov;

+                vCamera.FieldOfView = cameraFov;

                 setCameraRoll(vCamera);

             }

 

@@ -2055,7 +2052,7 @@ namespace MHWNewCamera
             {

                 vCamera.Position = cameraPosition;

                 vCamera.Target = cameraTarget;

-                vCamera.FieldOfView = (float)cameraFov;

+                vCamera.FieldOfView = cameraFov;

                 setCameraRoll(vCamera);

             }

 

@@ -2073,7 +2070,7 @@ namespace MHWNewCamera
             if (vCameraViewportIndex >= 0 && cameraRoll != 0.0f)

             {

                 Viewport vp = CameraSystem.GetViewport(vCameraViewportIndex);

-                vp.ViewMatrix *= Matrix4x4.CreateRotationZ((float)Double.DegreesToRadians(cameraRoll));

+                vp.ViewMatrix *= Matrix4x4.CreateRotationZ(Single.DegreesToRadians(cameraRoll));

             }

         }

         */

@@ -2668,10 +2665,10 @@ namespace MHWNewCamera
                 if (orbitPlayer && orbitIgnoreCamera && vCamera != null)

                 {

                     // Control the camera's influence on player movement separately.

-                    double dist = 700.0 - cameraForward;

-                    vCamera.Target.X = cameraPosition.X + (float)(dist * Math.Cos(Double.DegreesToRadians(orbitMovementRotation)));

+                    float dist = 700.0f - cameraForward;

+                    vCamera.Target.X = cameraPosition.X + dist * MathF.Cos(Single.DegreesToRadians(orbitMovementRotation));

                     vCamera.Target.Y = cameraPosition.Y;

-                    vCamera.Target.Z = cameraPosition.Z + (float)(dist * Math.Sin(Double.DegreesToRadians(orbitMovementRotation)));

+                    vCamera.Target.Z = cameraPosition.Z + dist * MathF.Sin(Single.DegreesToRadians(orbitMovementRotation));

                 }

                 if (playerMovementLocked && (plusRight == 0.0f && plusForward == 0.0f))

                 {

@@ -2958,8 +2955,8 @@ namespace MHWNewCamera
                             cameraPosition = new Vector3(pos.PosX, pos.PosY, pos.PosZ);

                             cameraTarget = new Vector3(pos.TargetX, pos.TargetY, pos.TargetZ);

                             Quaternion forward = Quaternion.Normalize(getForward(cameraPosition, cameraTarget));

-                            cameraYaw = Double.RadiansToDegrees(Math.Atan2(forward.Z, forward.X));

-                            cameraPitch = Double.RadiansToDegrees(Math.Asin(forward.Y));

+                            cameraYaw = Single.RadiansToDegrees(MathF.Atan2(forward.Z, forward.X));

+                            cameraPitch = Single.RadiansToDegrees(MathF.Asin(forward.Y));

                             camera.Position = cameraPosition;

                             camera.Target = cameraTarget;

                             cameraRoll = pos.Roll;

@@ -3004,21 +3001,9 @@ namespace MHWNewCamera
                         ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true);

                     }

                     // If our camera hooks aren't being run, these values won't be updated.

-                    float yaw = (float)cameraYaw;

-                    if (ImGui.DragFloat("Yaw", ref yaw, 0.2f))

-                    {

-                        cameraYaw = yaw;

-                    }

-                    float pitch = (float)cameraPitch;

-                    if (ImGui.DragFloat("Pitch", ref pitch, 0.2f))

-                    {

-                        cameraPitch = pitch;

-                    }

-                    float offsetRoll = (float)cameraRoll;

-                    if (ImGui.DragFloat("Roll", ref offsetRoll, 0.2f))

-                    {

-                        cameraRoll = offsetRoll;

-                    }

+                    ImGui.DragFloat("Yaw", ref cameraYaw, 0.2f);

+                    ImGui.DragFloat("Pitch", ref cameraPitch, 0.2f);

+                    ImGui.DragFloat("Roll", ref cameraRoll, 0.2f);

                     if (!usedByFreeCamera)

                     {

                         ImGui.PopItemFlag();

@@ -3388,21 +3373,15 @@ namespace MHWNewCamera
 

             ImGui.PushID("Perspective");

             ImGui.PushItemWidth(width * 0.575f);

-            float singleFov = (float)cameraFov;

-            if (ImGui.DragFloat("Field of View", ref singleFov, 0.4f, 1.0f, 179.0f))

-            {

-                cameraFov = singleFov;

-            }

+            ImGui.DragFloat("Field of View", ref cameraFov, 0.4f, 1.0f, 179.0f);

             ImGui.DragFloat("Forward", ref cameraForward, 0.25f);

             ImGui.DragFloat("Right", ref cameraRight, 0.25f);

             ImGui.DragFloat("Up", ref cameraYOffset, 0.025f);

-            float roll = (float)cameraRoll;

-            if (ImGui.DragFloat("Roll", ref roll, 0.25f))

+            if (ImGui.DragFloat("Roll", ref cameraRoll, 0.25f))

             {

-                cameraRoll = roll;

                 if (restoreRoll != null)

                 {

-                    restoreRoll = roll;

+                    restoreRoll = cameraRoll;

                 }

             }

             if (freeCamera)

@@ -3435,7 +3414,7 @@ namespace MHWNewCamera
                 cameraXOffset = 0.0f;

                 cameraYOffset = 0.0f;

                 cameraZOffset = 0.0f;

-                cameraRoll = 0.0;

+                cameraRoll = 0.0f;

                 if (restoreRoll != null)

                 {

                     restoreRoll = cameraRoll;

@@ -3529,13 +3508,11 @@ namespace MHWNewCamera
                 ImGui.EndTooltip();

             }

             ImGui.DragFloat("Zoom Speed", ref cameraZoomSpeed, 0.01f, 0.0f, 0.0f, "%.4f");

-            float pitchLimit = (float)cameraPitchLimit;

-            if (ImGui.InputFloat("Pitch Limit", ref pitchLimit, 0.0f, 0.0f, null, ImGuiInputTextFlags.EnterReturnsTrue))

+            if (ImGui.InputFloat("Pitch Limit", ref cameraPitchLimit, 0.0f, 0.0f, null, ImGuiInputTextFlags.EnterReturnsTrue))

             {

-                cameraPitchLimit = pitchLimit;

-                if (cameraPitchLimit != -1.0)

+                if (cameraPitchLimit != -1.0f)

                 {

-                    cameraPitchLimit = Math.Clamp(cameraPitchLimit, 0.0, Config.Settings.MAX_PITCH_LIMIT);

+                    cameraPitchLimit = Math.Clamp(cameraPitchLimit, 0.0f, Config.Settings.MAX_PITCH_LIMIT);

                 }

             }

             if (ImGui.BeginItemTooltip())