recrownedgtk/RecrownedAthenaeum/Graphics/Render/Camera2D.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;

namespace RecrownedAthenaeum.Graphics.Render
{
    /// <summary>
    /// A virtual 2D camera that wraps the normal <see cref="BasicCamera"/>. Default projection is orthographic.
    /// </summary>
    public class Camera2D : BasicCamera
    {
        /// <summary>
        /// The width of the view of the camera.
        /// </summary>
        public int viewWidth;

        /// <summary>
        /// The height of the view of the camera.
        /// </summary>
        public int viewHeight;

        /// <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 ConrnerPosition { set { position.X = value.X + viewWidth / 2f; position.Y = value.Y + viewHeight / 2f; } }

        /// <summary>
        /// A 2D camera from the generic <see cref="BasicCamera"/>.
        /// </summary>
        /// <param name="height">Width of camera view.</param>
        /// <param name="width">Height of camera view.</param>
        /// <param name="basicEffect">A basic effect that will be updated with the correct matrice information everytime <see cref="Apply"/> is called. Can be null and thus will not be used.</param>
        public Camera2D(int width, int height, BasicEffect basicEffect = null) : base(basicEffect)
        {
            this.viewWidth = width;
            this.viewHeight = height;
            upDirection = Vector3.Down;
            ConrnerPosition = new Vector2(0, 0);
            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()
        {
            projectionMatrix = Matrix.CreateOrthographic(viewWidth, viewHeight, 0, 1);
            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;
        }
    }
}