[3D]第一人称相机类Camera

自己根据C++ D3D的源码改写一个相机类(第一人称)。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.DirectX;
using Microsoft.DirectX.PrivateImplementationDetails;
using Microsoft.DirectX.Direct3D;

namespace AppScene
{
    public enum CameraType { LANDOBJECT, AIRCRAFT };
    public class Camera
    {
        CameraType mCameraType;
        Vector3 mPosition; //相机位置
        Vector3 mLook;//LookVector  
        Vector3 mUp;// UpVector  
        Vector3 mRight;// RightVector  
        Vector3 ViewFrustum;// 平面截投体  

        protected Viewport mViewPort;//视口大小
        protected Matrix m_ProjectionMatrix; //上一次渲染采用的投影变换矩阵 Projection matrix used in last render.
        protected Matrix m_ViewMatrix; //上一次渲染采用的观察矩阵 View matrix used in last render.
        protected Matrix m_WorldMatrix = Matrix.Identity;//世界变换矩阵
        public Camera()
        {
            mCameraType = CameraType.AIRCRAFT;
            mPosition = new Vector3(0.0f, 0.0f, -50.0f);//注意默认位置，现在对了。
            mRight = new Vector3(0.0f, 1.0f, 0.0f);
            mUp = new Vector3(0.0f, 1.0f, 0.0f);
            mLook = new Vector3(0.0f, 0.0f, 10.0f);
        }
        public Camera(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 upVector)
        {
            mCameraType = CameraType.AIRCRAFT;
            mPosition = new Vector3(0.0f, 0.0f, -100.0f);
            mRight = new Vector3(1.0f, 0.0f, 0.0f);
            mUp = new Vector3(0.0f, 1.0f, 0.0f);
            mLook = new Vector3(0.0f, 0.0f, 0.0f);
        }
        public void setCameraType(CameraType cameraType)
        {
            mCameraType = cameraType;
        }
        //前后移动
        public void walk(float units)
        {
            // move only on xz plane for land object
            if (mCameraType == CameraType.LANDOBJECT)
                mPosition += new Vector3(mLook.X, 0.0f, mLook.Z) * units;

            if (mCameraType == CameraType.AIRCRAFT)
                mPosition += mLook * units;
        }
        //左右移动，扫射
        public void strafe(float units)
        {
            // move only on xz plane for land object
            if (mCameraType == CameraType.LANDOBJECT)
                mPosition += new Vector3(mRight.X, 0.0f, mRight.Z) * units;

            if (mCameraType == CameraType.AIRCRAFT)
                mPosition += mRight * units;
        }
        //上下移动
        public void fly(float units)
        {
            // move only on y-axis for land object
            if (mCameraType == CameraType.LANDOBJECT)
                mPosition.Y += units;

            if (mCameraType == CameraType.AIRCRAFT)
                mPosition += mUp * units;
        }

        // 倾斜角 
        public void Pitch(float angle)
        {
            Matrix T = Matrix.Identity;
            //D3DXMatrixRotationAxis(&T, &_right, angle);
            T.RotateAxis(mRight, angle);
            // rotate _up and _look around _right vector
            mUp.TransformCoordinate(T);
            mLook.TransformCoordinate(T);
            //D3DXVec3TransformCoord(&_up, &_up, &T);
            //D3DXVec3TransformCoord(&_look, &_look, &T);
        }
        //俯仰角
        public void Roll(float angle)
        {
            // only roll for aircraft type
            if (mCameraType == CameraType.AIRCRAFT)
            {
                Matrix T = Matrix.Identity;
                T.RotateAxis(mLook, angle);

                // rotate _up and _right around _look vector
                mRight.TransformCoordinate(T);
                mUp.TransformCoordinate(T);
            }
        }
        // 航偏角
        public void Yaw(float angle)
        {
            Matrix T = Matrix.Identity;

            // rotate around world y (0, 1, 0) always for land object
            if (mCameraType == CameraType.LANDOBJECT)
                T.RotateY(angle);
            // rotate around own up vector for aircraft
            if (mCameraType == CameraType.AIRCRAFT)
                T.RotateAxis(mUp, angle);

            // rotate _right and _look around _up or y-axis
            mRight.TransformCoordinate(T);
            mLook.TransformCoordinate(T);
        }
        public void SetPosition(Vector3 position)// 设置相机世界坐标  
        {
            mPosition = position;
        }
        //更新相机状态
        public Matrix UpdateCamera()
        {
            Matrix mViewMatrix = Matrix.Identity;
            // Keep camera's axes orthogonal to eachother
            //D3DXVec3Normalize(&_look, &_look);
            mLook.Normalize();
            //D3DXVec3Cross(&, &_look, &_right);
            // _up = Vector3.Cross(_look, _right);
            //D3DXVec3Normalize(&_up, &_up);
            mUp.Normalize();
            //D3DXVec3Cross(&_right, &_up, &_look);
            mRight = Vector3.Cross(mUp, mLook);
            //D3DXVec3Normalize(&_right, &_right);
            mRight.Normalize();
            // Build the view matrix:
            //float x = -D3DXVec3Dot(&_right, &_pos);
            //float y = -D3DXVec3Dot(&_up, &_pos);
            //float z = -D3DXVec3Dot(&_look, &_pos);
            float x = -Vector3.Dot(mRight, mPosition);
            float y = -Vector3.Dot(mUp, mPosition);
            float z = -Vector3.Dot(mLook, mPosition);

            mViewMatrix.M11 = mRight.X; mViewMatrix.M12 = mUp.X; mViewMatrix.M13 = mLook.X; mViewMatrix.M14 = 0.0f;
            mViewMatrix.M21 = mRight.Y; mViewMatrix.M22 = mUp.Y; mViewMatrix.M23 = mLook.Y; mViewMatrix.M24 = 0.0f;
            mViewMatrix.M31 = mRight.Z; mViewMatrix.M32 = mUp.Z; mViewMatrix.M33 = mLook.Z; mViewMatrix.M34 = 0.0f;
            mViewMatrix.M41 = x; mViewMatrix.M42 = y; mViewMatrix.M43 = z; mViewMatrix.M44 = 1.0f;
            return mViewMatrix;
        }

        public void Update(Microsoft.DirectX.Direct3D.Device m_Device3d)
        {
            Matrix V = UpdateCamera();
            m_Device3d.SetTransform(TransformType.View, V);
        }
        //视口大小
        public Viewport Viewport
        {
            get
            {
                return mViewPort;
            }
        }
        //观察变换矩阵
        public Matrix ViewMatrix
        {
            get
            {
                return m_ViewMatrix;
            }
        }
        //投影变换矩阵
        public Matrix ProjectionMatrix
        {
            get
            {
                return m_ProjectionMatrix;
            }
        }
        //世界变换矩阵
        public Matrix WorldMatrix
        {
            get
            {
                return m_WorldMatrix;
            }
        }
        /// <summary>
        /// UnProject和Project之前需要调用该方法
        /// </summary>
        /// <param name="m_Device3d"></param>
        public void ComputeMatrix(Device m_Device3d)
        {
            m_WorldMatrix = m_Device3d.GetTransform(TransformType.World);
            m_ProjectionMatrix = m_Device3d.GetTransform(TransformType.Projection);
            m_ViewMatrix = m_Device3d.GetTransform(TransformType.View);
            mViewPort = m_Device3d.Viewport;
        }
        /// <summary>
        /// Projects a point from world to screen coordinates.
        /// 计算指定世界坐标的屏幕坐标
        /// </summary>
        /// <param name="point">Point in world space</param>
        /// <returns>Point in screen space</returns>
        public Vector3 Project(Vector3 point)
        {
            point.Project(mViewPort, m_ProjectionMatrix, m_ViewMatrix, m_WorldMatrix);
            return point;
        }

        internal Vector3 UnProject(Vector3 v1)
        {
            v1.Unproject(mViewPort, m_ProjectionMatrix, m_ViewMatrix, m_WorldMatrix);
            return v1;
        }
    }
}

增加一个围绕某条射线旋转的方法：

 //
        public void RotateRay(float angle, Vector3 vOrigin, Vector3 vAxis)
        {
            // 计算新的焦点
            Vector3 vView = mLook - vOrigin;
            Matrix temp = Matrix.RotationAxis(vAxis, angle);
            vView.TransformCoordinate(temp);
            //vView.RotateAxis(angle, vAxis);
            mLook = vOrigin + vView;

            // 计算新的视点
            vView = mPosition - vOrigin;
           // Matrix temp2 = Matrix.RotationAxis(vAxis, angle);
            vView.TransformCoordinate(temp);
            //vView.RotateAxis(angle, vAxis);
            mPosition = vOrigin + vView;

            mUp.TransformCoordinate(temp);
          //  m_strafe.RotateAxis(angle, vAxis);
        }