Attempted at fixing 2D camera system.

RecrownedAthenaeum/View/Camera2D.cs

@@ -0,0 +1,72 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+
+namespace RecrownedAthenaeum.Camera
+{
+    /// <summary>
+    /// A virtual 2D camera that wraps the normal <see cref="Camera3D"/>. Default projection is orthographic.
+    /// </summary>
+    public class Camera2D : Camera3D
+    {
+
+        /// <summary>
+        /// The 2D position.
+        /// </summary>
+        public Vector2 Position { get { return new Vector2(position.X, position.Y); } set { position.X = value.X; position.Y = value.Y; } }
+
+        /// <summary>
+        /// Places camera in the center given the corner position.
+        /// </summary>
+        public Vector2 CenterPosition { set { position.X = value.X + graphicsDevice.Viewport.Width / 2f; position.Y = value.Y + graphicsDevice.Viewport.Height / 2f; } }
+
+        /// <summary>
+        /// A 2D camera from the generic <see cref="Camera3D"/>.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device to use if not using the one in <see cref="Configuration"/>.</param>
+        public Camera2D(GraphicsDevice graphicsDevice = null) : base(graphicsDevice)
+        {
+            projectionMatrix = Matrix.CreateOrthographic(this.graphicsDevice.Viewport.Width, this.graphicsDevice.Viewport.Height, 0, 1);
+            CenterPosition = new Vector2(0, 0);
+            upDirection = Vector3.Down;
+            Apply();
+        }
+
+        /// <summary>
+        /// Applies for 2D.
+        /// Sets where the camera is looking for the view matrix to the position of the camera.
+        /// </summary>
+        public override void Apply()
+        {
+            position.Z = 0;
+            lookAt = new Vector3(Position, 1f);
+            base.Apply();
+        }
+
+        /// <summary>
+        /// Lerps to the given position.
+        /// </summary>
+        /// <param name="alpha">The multiplier for difference in distance.</param>
+        /// <param name="targetPosition">The target position to lerp to.</param>
+        /// <param name="delta">Time between this frame and the previous frame.</param>
+        public void LinearInterpolationToPosition(float alpha, Vector2 targetPosition, float delta)
+        {
+            if (alpha <= 0 && alpha > 1f) throw new ArgumentException("Alpha can't be greater than 1f, less than or equal to 0.");
+
+            Vector2 distance = targetPosition - Position;
+            distance *= (float)(1.0f - Math.Pow(1 - alpha, delta / 0.02f));
+
+            Position += distance;
+        }
+
+        /// <summary>
+        /// Moves the camera.
+        /// Apply needs to be called.
+        /// </summary>
+        /// <param name="move">Magnitude of how much to move per axis.</param>
+        public void MoveCamera(Vector2 move)
+        {
+            Position += move;
+        }
+    }
+}

RecrownedAthenaeum/View/Camera3D.cs

@@ -0,0 +1,103 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RecrownedAthenaeum.Camera
+{
+    /// <summary>
+    /// A generic 3D camera.
+    /// </summary>
+    public class Camera3D
+    {
+        /// <summary>
+        /// Current position in the world.
+        /// </summary>
+        public Vector3 position;
+
+        /// <summary>
+        /// The place the 3D camera is looking at.
+        /// </summary>
+        public Vector3 lookAt;
+
+        /// <summary>
+        /// The direction up is for the 3D camera.
+        /// </summary>
+        public Vector3 upDirection;
+
+        /// <summary>
+        /// The transform matrix representing the world (rotation and translations of the original world).
+        /// </summary>
+        public Matrix worldMatrix;
+
+        /// <summary>
+        /// The view matrix that describes where the camera looks.
+        /// </summary>
+        public Matrix ViewMatrix { get; private set; }
+
+        /// <summary>
+        /// The projection matrix.
+        /// </summary>
+        public Matrix projectionMatrix;
+
+        /// <summary>
+        /// The final transformation matrix.
+        /// </summary>
+        public Matrix TransformationMatrix { get; private set; }
+
+        /// <summary>
+        /// The graphics device used 
+        /// </summary>
+        protected GraphicsDevice graphicsDevice;
+
+        /// <summary>
+        /// The basic effect that contains the transformations.
+        /// </summary>
+        public BasicEffect BasicEffect { get; private set; }
+
+        /// <summary>
+        /// Constructs 3D camera with an orthographic projection matrix with dimensions of graphics devices viewport. All changes to matrices should have apply called after changes.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device to use. Will use graphics device from <see cref="Configuration"/>'s graphics device manager if this is null which it is by default.</param>
+        public Camera3D(GraphicsDevice graphicsDevice = null)
+        {
+            graphicsDevice = graphicsDevice ?? (Configuration.GraphicsDeviceManager.GraphicsDevice);
+            this.graphicsDevice = graphicsDevice;
+            worldMatrix = Matrix.Identity;
+            lookAt = Vector3.Forward;
+            upDirection = Vector3.Up;
+
+            projectionMatrix = Matrix.Identity;
+
+            BasicEffect = new BasicEffect(graphicsDevice);
+            BasicEffect.TextureEnabled = true;
+            Apply();
+        }
+
+        /// <summary>
+        /// Applies the changes to the fields and properties of the camera.
+        /// </summary>
+        public virtual void Apply()
+        {
+            ViewMatrix = Matrix.CreateLookAt(position, lookAt, upDirection);
+            TransformationMatrix = projectionMatrix * ViewMatrix * worldMatrix;
+
+            BasicEffect.World = worldMatrix;
+            BasicEffect.View = ViewMatrix;
+            BasicEffect.Projection = projectionMatrix;
+        }
+
+        /// <summary>
+        /// Moves camera by the given amount.
+        /// </summary>
+        /// <param name="move">A <see cref="Vector3"/> that contains how much in each direction to move.</param>
+        public void MoveCamera(Vector3 move)
+        {
+            position += move;
+            Apply();
+        }
+    }
+}