Desktop/Dev/Cameras/Cameras/QuaternionCamera.cs

Go to the documentation of this file.

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

namespace Mindshifter
{
    public enum TransformSpace
    {
        CameraSpace,
        WorldSpace,
    }

    public sealed class QuaternionCamera : ICamera
    {
        private Matrix          mViewMatrix;
        private Matrix          mInverseViewMatrix;

        private Projection      mProjection;

        private Vector3         mPosition;
        private Quaternion      mOrientation;

        private bool            mRequiresUpdate;

        public Matrix ViewMatrix
        {
            get
            {
                if (mRequiresUpdate)
                    BuildMatrix();

                return mViewMatrix;
            }
        }

        public Matrix InverseViewMatrix
        {
            get
            {
                if (mRequiresUpdate)
                    BuildMatrix();

                return mInverseViewMatrix;
            }
        }

        public Matrix ProjectionMatrix
        {
            get { return mProjection.Matrix; }
        }

        public Projection Projection
        {
            get { return mProjection; }
        }

        public Vector3 Position
        {
            get { return mPosition; }
            set
            {
                mPosition = value;
                mRequiresUpdate = true;
            }
        }

        public Quaternion Orientation
        {
            get { return mOrientation; }
            set
            {
                Quaternion.Normalize(ref value, out mOrientation);
                mRequiresUpdate = true;
            }
        }

        public float X
        {
            get { return mPosition.X; }
            set
            {
                mPosition.X = value;
                mRequiresUpdate = true;
            }
        }

        public float Y
        {
            get { return mPosition.Y; }
            set
            {
                mPosition.Y = value;
                mRequiresUpdate = true;
            }
        }

        public float Z
        {
            get { return mPosition.Z; }
            set
            {
                mPosition.Z = value;
                mRequiresUpdate = true;
            }
        }

        public Vector3 Up
        {
            get
            {
                if (mRequiresUpdate)
                    BuildMatrix();

                return mInverseViewMatrix.Up;
            }
        }

        public Vector3 Forward
        {
            get
            {
                if (mRequiresUpdate)
                    BuildMatrix();

                return mInverseViewMatrix.Forward;
            }
        }

        public Vector3 Right
        {
            get
            {
                if (mRequiresUpdate)
                    BuildMatrix();

                return mInverseViewMatrix.Right;
            }
        }

        public BoundingFrustum Frustum
        {
            get { return new BoundingFrustum(ViewMatrix * ProjectionMatrix); }
        }

        public QuaternionCamera() 
            : this(Vector3.Zero, Quaternion.Identity, (float)Math.PI / 4f, 4f /3f, 1f, 1000f)
        {

        }

        public QuaternionCamera(Vector3 position, Quaternion orientation)
            : this(position, orientation, (float)Math.PI / 4f, 4f / 3f, 1f, 1000f)
        {

        }

        public QuaternionCamera(Vector3 position, Quaternion orientation, float fov, 
                                    float aspect, float near, float far)
        {
            mPosition = position;
            mOrientation = orientation;
            mViewMatrix = Matrix.Identity;
            mInverseViewMatrix = Matrix.Identity;

            mProjection = new Projection(fov, aspect, near, far);

            mRequiresUpdate = true;
        }

        public QuaternionCamera(Vector3 position, Quaternion orientation, Rectangle rect, 
                                    float near, float far)
        {
            mPosition = position;
            mOrientation = orientation;
            mViewMatrix = Matrix.Identity;
            mInverseViewMatrix = Matrix.Identity;

            mProjection = new Projection(rect.X, rect.Y, rect.Width, rect.Height, near, far);

            mRequiresUpdate = true;
        }

        public void Pitch(float pitchAmount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mOrientation *= Quaternion.CreateFromAxisAngle(Vector3.Normalize(mInverseViewMatrix.Right), pitchAmount);
                    break;

                case TransformSpace.WorldSpace:
                    mOrientation *= Quaternion.CreateFromAxisAngle(Vector3.Right, pitchAmount);
                    break;
            }

            mRequiresUpdate = true;
        }

        public void Pitch(float pitchAmount)
        {
            Pitch(pitchAmount, TransformSpace.CameraSpace);
        }

        public void Yaw(float yawAmount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mOrientation *= Quaternion.CreateFromAxisAngle(Vector3.Normalize(mInverseViewMatrix.Up), yawAmount);
                    break;

                case TransformSpace.WorldSpace:
                    mOrientation *= Quaternion.CreateFromAxisAngle(Vector3.Up, yawAmount);
                    break;
            }

            mRequiresUpdate = true;
        }

        public void Yaw(float yawAmount)
        {
            Yaw(yawAmount, TransformSpace.CameraSpace);
        }

        public void Roll(float rollAmount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mOrientation *= Quaternion.CreateFromAxisAngle(Vector3.Normalize(mInverseViewMatrix.Backward), rollAmount);
                    break;

                case TransformSpace.WorldSpace:
                    mOrientation *= Quaternion.CreateFromAxisAngle(Vector3.Backward, rollAmount);
                    break;
            }

            mRequiresUpdate = true;
        }

        public void Roll(float rollAmount)
        {
            Roll(rollAmount, TransformSpace.CameraSpace);
        }

        public void Translate(Vector3 amount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mPosition += mInverseViewMatrix.Right * amount.X +
                        mInverseViewMatrix.Up * amount.Y + mInverseViewMatrix.Backward * amount.Z;
                    break;

                case TransformSpace.WorldSpace:
                    mPosition += amount;
                    break;
            }

            mRequiresUpdate = true;
        }

        public void Translate(Vector3 amount)
        {
            Translate(amount, TransformSpace.CameraSpace);
        }

        public void TranslateX(float amount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mPosition += mInverseViewMatrix.Right * amount;
                    break;

                case TransformSpace.WorldSpace:
                    mPosition.X += amount;
                    break;
            }

            mRequiresUpdate = true;
        }

        public void TranslateX(float amount)
        {
            TranslateX(amount, TransformSpace.CameraSpace);
        }

        public void TranslateY(float amount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mPosition += mInverseViewMatrix.Up * amount;
                    break;

                case TransformSpace.WorldSpace:
                    mPosition.Y += amount;
                    break;
            }

            mRequiresUpdate = true;
        }

        public void TranslateY(float amount)
        {
            TranslateY(amount, TransformSpace.CameraSpace);
        }

        public void TranslateZ(float amount, TransformSpace space)
        {
            if (mRequiresUpdate)
                BuildMatrix();

            switch (space)
            {
                case TransformSpace.CameraSpace:
                    mPosition += mInverseViewMatrix.Backward * amount;
                    break;

                case TransformSpace.WorldSpace:
                    mPosition.Z += amount;
                    break;
            }

            mRequiresUpdate = true;
        }

        public void TranslateZ(float amount)
        {
            TranslateZ(amount, TransformSpace.CameraSpace);
        }

        private void BuildMatrix()
        {
            Vector3 P;
            Quaternion O;
            Matrix T;
            Matrix R;

            Vector3.Negate(ref mPosition, out P);
            Quaternion.Negate(ref mOrientation, out O);

            Matrix.CreateTranslation(ref P, out T);
            Matrix.CreateFromQuaternion(ref O, out R);

            Matrix.Multiply(ref T, ref R, out mViewMatrix);
            Matrix.Invert(ref mViewMatrix, out mInverseViewMatrix);

            mRequiresUpdate = false;
        }

        public void Update(float elapsedSeconds)
        {
            if (mRequiresUpdate)
                BuildMatrix();
        }

        public Ray GetPickRay(Vector2 position, Viewport viewport)
        {
            Vector3 near = viewport.Unproject(new Vector3(position, 0f), ProjectionMatrix,
                                ViewMatrix, Matrix.Identity);

            Vector3 far = viewport.Unproject(new Vector3(position, 1f), ProjectionMatrix,
                                ViewMatrix, Matrix.Identity);

            return new Ray(near, Vector3.Normalize(far - near));
        }
    }
}

---