Desktop/Dev/Cameras/Cameras/OrbitCamera.cs

Go to the documentation of this file.

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

namespace Mindshifter
{
    public sealed class OrbitCamera : ICamera
    {
        private Matrix          mViewMatrix;
        private Projection      mProjection;

        private CameraSpring    mLookAtSpring;
        private CameraSpring    mEyeSpring;

        private bool            mLookAtSpringEnabled;
        private bool            mEyeSpringEnabled;

        private float           mAzimuth;
        private float           mDeclination;
        private float           mRadius;

        private float           mMinAzimuth;
        private float           mMaxAzimuth;
        private float           mMinDeclination;
        private float           mMaxDeclination;
        private float           mMinRadius;
        private float           mMaxRadius;

        public Matrix ViewMatrix
        {
            get { return mViewMatrix; }
        }

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

        public Projection Projection
        {
            get { return mProjection; }
        }

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

        public Vector3 Position
        {
            get 
            { 
                if(mEyeSpringEnabled)
                    return mEyeSpring.Position;

                return mEyeSpring.Origin;
            }
        }

        public Vector3 LookAtPoint
        {
            get 
            {
                if(mLookAtSpringEnabled)
                    return mLookAtSpring.Position;

                return mLookAtSpring.Origin;
            }

            set { mLookAtSpring.Origin = value; }
        }

        public bool EyeSpringEnabled
        {
            get { return mEyeSpringEnabled; }
            set { mEyeSpringEnabled = value; }
        }

        public float EyeSpringStiffness
        {
            get { return mEyeSpring.Stiffness; }
            set { mEyeSpring.Stiffness = value; }
        }

        public float EyeSpringDamping
        {
            get { return mEyeSpring.Damping; }
            set { mEyeSpring.Damping = value; }
        }

        public bool LookAtSpringEnabled
        {
            get { return mLookAtSpringEnabled; }
            set { mLookAtSpringEnabled = value; }
        }

        public float LookAtSpringStiffness
        {
            get { return mLookAtSpring.Stiffness; }
            set { mLookAtSpring.Stiffness = value; }
        }

        public float LookAtSpringDamping
        {
            get { return mLookAtSpring.Damping; }
            set { mLookAtSpring.Damping = value; }
        }

        public float Azimuth
        {
            get { return mAzimuth; }
            set { mAzimuth = MathHelper.Clamp(value, mMinAzimuth, mMaxAzimuth); }
        }

        public float Declination
        {
            get { return mDeclination; }
            set { mDeclination = MathHelper.Clamp(value, mMinDeclination, mMaxDeclination); }
        }

        public float Radius
        {
            get { return mRadius; }
            set { mRadius = MathHelper.Clamp(value, mMinRadius, mMaxRadius); }
        }

        public float MinimumAzimuth
        {
            get { return mMinAzimuth; }
            set
            {
                mMinAzimuth = MathHelper.Clamp(value, float.MinValue, float.MaxValue);

                if (mMaxAzimuth < mMinAzimuth)
                    mMaxAzimuth = mMinAzimuth;

                mAzimuth = MathHelper.Clamp(mAzimuth, mMinAzimuth, mMaxAzimuth);
            }
        }

        public float MaximumAzimuth
        {
            get { return mMaxAzimuth; }
            set
            {
                mMaxAzimuth = MathHelper.Clamp(value, float.MinValue, float.MaxValue);

                if (mMinAzimuth > mMaxAzimuth)
                    mMinAzimuth = mMaxAzimuth;

                mAzimuth = MathHelper.Clamp(mAzimuth, mMinAzimuth, mMaxAzimuth);
            }
        }

        public float MinimumDeclination
        {
            get { return mMinDeclination; }
            set
            {
                mMinDeclination = MathHelper.Clamp(value, float.Epsilon, (float)Math.PI - float.Epsilon);

                if (mMaxDeclination < mMinDeclination)
                    mMaxDeclination = mMinDeclination;

                mDeclination = MathHelper.Clamp(mDeclination, mMinDeclination, mMaxDeclination);
            }
        }

        public float MaximumDeclination
        {
            get { return mMaxDeclination; }
            set
            {
                mMaxDeclination = MathHelper.Clamp(value, float.Epsilon, (float)Math.PI - float.Epsilon);

                if (mMinDeclination > mMaxDeclination)
                    mMinDeclination = mMaxDeclination;

                mDeclination = MathHelper.Clamp(mDeclination, mMinDeclination, mMaxDeclination);
            }
        }

        public float MinimumRadius
        {
            get { return mMinRadius; }
            set
            {
                mMinRadius = MathHelper.Clamp(value, float.Epsilon, float.MaxValue);

                if (mMaxRadius < mMinRadius)
                    mMaxRadius = mMinRadius;

                mRadius = MathHelper.Clamp(mRadius, mMinRadius, mMaxRadius);
            }
        }

        public float MaximumRadius
        {
            get { return mMaxRadius; }
            set
            {
                mMaxRadius = MathHelper.Clamp(value, float.Epsilon, float.MaxValue);

                if (mMinRadius > mMaxRadius)
                    mMinRadius = mMaxRadius;

                mRadius = MathHelper.Clamp(mRadius, mMinRadius, mMaxRadius);
            }
        }

        public OrbitCamera()
            : this(0f, (float)Math.PI /2f, 1f, (float)Math.PI / 4f, 4f / 3f, 1f, 1000f)
        {
            
        }

        public OrbitCamera(float azimuth, float declination, float radius)
            : this(azimuth, declination, radius, (float)Math.PI / 4f, 4f / 3f, 1f, 1000f)
        {

        }

        public OrbitCamera(float azimuth, float declination, float radius, float fov, 
                            float aspect, float near, float far)
        {
            mProjection = new Projection(fov, aspect, near, far);

            mEyeSpring = new CameraSpring();
            mLookAtSpring = new CameraSpring();

            mEyeSpringEnabled = false;
            mLookAtSpringEnabled = false;

            mMinAzimuth = float.MinValue;
            mMaxAzimuth = float.MaxValue;
            mMinDeclination = float.Epsilon;
            mMaxDeclination = (float)Math.PI - float.Epsilon;
            mMinRadius = float.Epsilon;
            mMaxRadius = float.MaxValue;

            mAzimuth = MathHelper.Clamp(azimuth, mMinAzimuth, mMaxAzimuth);
            mDeclination = MathHelper.Clamp(declination, mMinDeclination, mMaxDeclination);
            mRadius = MathHelper.Clamp(radius, mMinRadius, mMaxRadius);
        }

        public OrbitCamera(float azimuth, float declination, float radius, Rectangle rect, 
                            float near, float far)
        {
            mProjection = new Projection(rect, near, far);

            mEyeSpring = new CameraSpring();
            mLookAtSpring = new CameraSpring();

            mEyeSpringEnabled = false;
            mLookAtSpringEnabled = false;

            mMinAzimuth = float.MinValue;
            mMaxAzimuth = float.MaxValue;
            mMinDeclination = float.Epsilon;
            mMaxDeclination = (float)Math.PI - float.Epsilon;
            mMinRadius = float.Epsilon;
            mMaxRadius = float.MaxValue;

            mAzimuth = MathHelper.Clamp(azimuth, mMinAzimuth, mMaxAzimuth);
            mDeclination = MathHelper.Clamp(declination, mMinDeclination, mMaxDeclination);
            mRadius = MathHelper.Clamp(radius, mMinRadius, mMaxRadius);
        }

        public void Yaw(float value)
        {
            Azimuth += value;
        }

        public void Pitch(float value)
        {
            Declination += value;
        }

        public void Zoom(float value)
        {
            Radius += value;
        }

        public void Update(float elapsedSeconds)
        {
            Vector3 eye = Vector3.Zero;

            eye.X = mRadius * (float)Math.Sin(mDeclination) * (float)Math.Cos(mAzimuth);
            eye.Z = mRadius * (float)Math.Sin(mDeclination) * (float)Math.Sin(mAzimuth);
            eye.Y = mRadius * (float)Math.Cos(mDeclination);

            mEyeSpring.Origin = LookAtPoint + eye;

            mEyeSpring.Update(elapsedSeconds);
            mLookAtSpring.Update(elapsedSeconds);

            mViewMatrix = Matrix.CreateLookAt(Position, LookAtPoint, Vector3.UnitY);
        }

        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));
        }
    }
}

---