CSharpGL(4)设计和使用Camera

CSharpGL(4)设计和使用Camera

+BIT祝威+悄悄在此留下版了个权的信息说：

主要内容

描述在OpenGL中Camera的概念和用处。

设计一个Camera以及操控Camera的SatelliteRotator。

以PyramidElement为例演示如何使用Camera和SatelliteRotator。

+BIT祝威+悄悄在此留下版了个权的信息说：

下载

您可以在（https://github.com/bitzhuwei/CSharpGL）找到最新的源码。欢迎感兴趣的同学fork之。

+BIT祝威+悄悄在此留下版了个权的信息说：

Camera

在OpenGL中的Camera概念可以方便我们设定projection矩阵和view矩阵。

定义

    /// <summary>
    /// 摄像机。
    /// </summary>
    public class Camera :
        ICamera,
        IPerspectiveViewCamera, IOrthoViewCamera,
        IViewCamera, IPerspectiveCamera, IOrthoCamera
    {
        /// <summary>
        /// 默认目标为vec3(0, 0, 0)
        /// </summary>
        public static readonly vec3 defaultTarget = new vec3(0, 0, 0);

        /// <summary>
        /// 默认位置为vec3(0, 0, 1)
        /// </summary>
        public static readonly vec3 defaultPosition = new vec3(0, 0, 1);

        /// <summary>
        /// 默认上方为vec3(0, 1, 0)
        /// </summary>
        public static readonly vec3 defaultUpVector = new vec3(0, 1, 0);

        internal Camera() { }

        /// <summary>
        /// 摄像机。
        /// </summary>
        /// <param name="cameraType">类型</param>
        /// <param name="width">OpenGL窗口的宽度</param>
        /// <param name="height">OpenGL窗口的高度</param>
        public Camera(CameraType cameraType, double width, double height)
        {
            this.lastHeight = width;
            this.lastHeight = height;

            IPerspectiveCamera perspectiveCamera = this;
            perspectiveCamera.FieldOfView = 60.0f;
            perspectiveCamera.AspectRatio = width / height;
            perspectiveCamera.Near = 0.01;
            perspectiveCamera.Far = 10000;

            const int factor = 100;
            IOrthoCamera orthoCamera = this;
            orthoCamera.Left = -width / 2 / factor;
            orthoCamera.Right = width / 2 / factor;
            orthoCamera.Bottom = -height / 2 / factor;
            orthoCamera.Top = height / 2 / factor;
            orthoCamera.Near = -10000;
            orthoCamera.Far = 10000;

            this.Target = defaultTarget;
            this.Position = defaultPosition;
            this.UpVector = defaultUpVector;

            this.CameraType = cameraType;
        }

        public void Resize(double width, double height)
        {
            double aspectRatio = width / height;

            IPerspectiveCamera perspectiveCamera = this;
            perspectiveCamera.AspectRatio = aspectRatio;

            IOrthoCamera orthoCamera = this;

            double lastAspectRatio = this.lastWidth / this.lastHeight;
            if (aspectRatio > lastAspectRatio)
            {
                double top = orthoCamera.Top;
                double newRight = top * aspectRatio;
                orthoCamera.Left = -newRight;
                orthoCamera.Right = newRight;
            }
            else if (aspectRatio < lastAspectRatio)
            {
                double right = orthoCamera.Right;
                double newTop = right / aspectRatio;
                orthoCamera.Bottom = -newTop;
                orthoCamera.Top = newTop;
            }

            //const int factor = 100;
            //if (width / 2 / factor != orthoCamera.Right)
            //{
            //    orthoCamera.Left = -width / 2 / factor;
            //    orthoCamera.Right = width / 2 / factor;
            //}
            //if (height / 2 / factor != orthoCamera.Top)
            //{
            //    orthoCamera.Bottom = -height / 2 / factor;
            //    orthoCamera.Top = height / 2 / factor;
            //}
        }

        double lastWidth;
        double lastHeight;

        /// <summary>
        /// Gets or sets the target.
        /// </summary>
        /// <value>
        /// The target.
        /// </value>
        [Description("The target of the camera (the point it's looking at)"), Category("Camera")]
        public vec3 Target { get; set; }

        /// <summary>
        /// Gets or sets up vector.
        /// </summary>
        /// <value>
        /// Up vector.
        /// </value>
        [Description("The up direction, relative to camera. (Controls tilt)."), Category("Camera")]
        public vec3 UpVector { get; set; }

        /// <summary>
        /// The camera position.
        /// </summary>
        private vec3 position = new vec3(0, 0, 0);

        /// <summary>
        /// Every time a camera is used to project, the projection matrix calculated
        /// and stored here.
        /// </summary>
        private mat4 projectionMatrix = mat4.identity();

        ///// <summary>
        ///// The screen aspect ratio.
        ///// </summary>
        //private double aspectRatio = 1.0f;

        /// <summary>
        /// Gets or sets the position.
        /// </summary>
        /// <value>
        /// The position.
        /// </value>
        [Description("The position of the camera"), Category("Camera")]
        public vec3 Position
        {
            get { return position; }
            set { position = value; }
        }

        /// <summary>
        /// camera's perspective type.
        /// </summary>
        public CameraType CameraType { get; set; }

        #region IPerspectiveCamera 成员

        double IPerspectiveCamera.FieldOfView { get; set; }

        double IPerspectiveCamera.AspectRatio { get; set; }

        double IPerspectiveCamera.Near { get; set; }

        double IPerspectiveCamera.Far { get; set; }

        #endregion

        #region IOrthoCamera 成员

        double IOrthoCamera.Left { get; set; }

        double IOrthoCamera.Right { get; set; }

        double IOrthoCamera.Bottom { get; set; }

        double IOrthoCamera.Top { get; set; }

        double IOrthoCamera.Near { get; set; }

        double IOrthoCamera.Far { get; set; }

        #endregion
    }

+BIT祝威+悄悄在此留下版了个权的信息说：

通过Camera获取矩阵

根据上面的Camera的定义，很容易给出其对应的projection矩阵和view矩阵。

    public static class Camera2Matrix
    {

        /// <summary>
        /// 根据摄像机的类型获取其投影矩阵
        /// </summary>
        /// <param name="camera"></param>
        /// <returns></returns>
        public static mat4 GetProjectionMat4(this ICamera camera)
        {
            mat4 result;

            switch (camera.CameraType)
            {
                case CameraType.Perspecitive:
                    result = ((IPerspectiveCamera)camera).GetProjectionMat4();
                    break;
                case CameraType.Ortho:
                    result = ((IOrthoCamera)camera).GetProjectionMat4();
                    break;
                default:
                    throw new NotImplementedException();
            }

            return result;
        }

        /// <summary>
        /// Extension method for <see cref="IPerspectiveCamera"/> to get projection matrix.
        /// </summary>
        /// <param name="camera"></param>
        /// <returns></returns>
        public static mat4 GetProjectionMat4(this IPerspectiveCamera camera)
        {
            mat4 perspective = glm.perspective(
                (float)(camera.FieldOfView * Math.PI / 180.0f),
                (float)camera.AspectRatio, (float)camera.Near, (float)camera.Far);
            return perspective;
        }

        /// <summary>
        /// Extension method for <see cref="IOrthoCamera"/> to get projection matrix.
        /// </summary>
        /// <param name="camera"></param>
        /// <returns></returns>
        public static mat4 GetProjectionMat4(this IOrthoCamera camera)
        {
            mat4 ortho = glm.ortho(
                (float)camera.Left, (float)camera.Right,
                (float)camera.Bottom, (float)camera.Top,
                (float)camera.Near, (float)camera.Far);
            return ortho;
        }

        /// <summary>
        /// Extension method for <see cref="IViewCamera"/> to get view matrix.
        /// </summary>
        /// <param name="camera"></param>
        /// <returns></returns>
        public static mat4 GetViewMat4(this IViewCamera camera)
        {
            mat4 lookAt = glm.lookAt(camera.Position, camera.Target, camera.UpVector);
            return lookAt;
        }
    }

+BIT祝威+悄悄在此留下版了个权的信息说：

缩放Camera

    public static class MouseWheelHelper
    {
        /// <summary>
        /// 对摄像机执行一次缩放操作
        /// </summary>
        /// <param name="camera"></param>
        /// <param name="delta"></param>
        public static void MouseWheel(this ICamera camera, int delta)
        {
            //if (camera.CameraType == CameraTypes.Perspecitive)
            {
                var target2Position = camera.Position - camera.Target;
                if (target2Position.Magnitude() < 0.01)
                {
                    target2Position.Normalize();
                    target2Position.x *= 0.01f;
                    target2Position.y *= 0.01f;
                    target2Position.z *= 0.01f;
                }
                var scaledTarget2Position = target2Position * (1 - delta * 0.001f);
                camera.Position = camera.Target + scaledTarget2Position;
                double lengthDiff = scaledTarget2Position.Magnitude() - target2Position.Magnitude();
                // Increase ortho camera's Near/Far property in case the camera's position changes too much.
                IPerspectiveCamera perspectiveCamera = camera;
                perspectiveCamera.Far += lengthDiff;
                //perspectiveCamera.Near += lengthDiff;
                IOrthoCamera orthoCamera = camera;
                orthoCamera.Far += lengthDiff;
                orthoCamera.Near += lengthDiff;
            }
            //else if (camera.CameraType == CameraTypes.Ortho)
            {
                IOrthoCamera orthoCamera = camera;
                double distanceX = orthoCamera.Right - orthoCamera.Left;
                double distanceY = orthoCamera.Top - orthoCamera.Bottom;
                double centerX = (orthoCamera.Left + orthoCamera.Right) / 2;
                double centerY = (orthoCamera.Bottom + orthoCamera.Top) / 2;
                orthoCamera.Left = centerX - distanceX * (1 - delta * 0.001) / 2;
                orthoCamera.Right = centerX + distanceX * (1 - delta * 0.001) / 2;
                orthoCamera.Bottom = centerY - distanceY * (1 - delta * 0.001) / 2;
                orthoCamera.Top = centerX + distanceY * (1 - delta * 0.001) / 2;
            }
        }

    }

+BIT祝威+悄悄在此留下版了个权的信息说：

Rotator

有了Camera，我们就想通过改变Camera的位置、朝向来实现在场景中进行移动的功能。SatelliteRotator可以根据鼠标操作使Camera围绕其Target在给定的球面上移动，就像卫星围绕恒星运动一样。

    /// <summary>
    /// Rotates a camera on a sphere, whose center is camera's Target.
    /// <para>Just like a satellite moves around a fixed star.</para>
    /// </summary>
    public class SatelliteRotator : ICameraRotator
    {
        private Point downPosition = new Point();
        private Size bound = new Size();
        public bool mouseDownFlag = false;
        private float horizontalRotationFactor = 4;
        private float verticalRotationFactor = 4;
        private vec3 up;
        private vec3 back;
        private vec3 right;

        /// <summary>
        /// Rotates a camera on a sphere, whose center is camera's Target.
        /// <para>Just like a satellite moves around a fixed star.</para>
        /// </summary>
        /// <param name="camera"></param>
        public SatelliteRotator(ICamera camera = null)
        {
            this.Camera = camera;
        }


        public override string ToString()
        {
            return string.Format("back:{0}|{3:0.00},up:{1}|{4:0.00},right:{2}|{5:0.00}",
                back, up, right, back.Magnitude(), up.Magnitude(), right.Magnitude());
            //return base.ToString();
        }


        private ICamera originalCamera;

        public ICamera Camera { get; set; }

        public void MouseUp(int x, int y)
        {
            this.mouseDownFlag = false;
        }

        public void MouseMove(int x, int y)
        {
            if (this.mouseDownFlag)
            {
                IViewCamera camera = this.Camera;
                if (camera == null) { return; }

                vec3 back = this.back;
                vec3 right = this.right;
                vec3 up = this.up;
                Size bound = this.bound;
                Point downPosition = this.downPosition;
                {
                    float deltaX = -horizontalRotationFactor * (x - downPosition.X) / bound.Width;
                    float cos = (float)Math.Cos(deltaX);
                    float sin = (float)Math.Sin(deltaX);
                    vec3 newBack = new vec3(
                        back.x * cos + right.x * sin,
                        back.y * cos + right.y * sin,
                        back.z * cos + right.z * sin);
                    back = newBack;
                    right = up.cross(back);
                    back.Normalize();
                    right.Normalize();
                }
                {
                    float deltaY = verticalRotationFactor * (y - downPosition.Y) / bound.Height;
                    float cos = (float)Math.Cos(deltaY);
                    float sin = (float)Math.Sin(deltaY);
                    vec3 newBack = new vec3(
                        back.x * cos + up.x * sin,
                        back.y * cos + up.y * sin,
                        back.z * cos + up.z * sin);
                    back = newBack;
                    up = back.cross(right);
                    back.Normalize();
                    up.Normalize();
                }

                camera.Position = camera.Target +
                    back * (float)((camera.Position - camera.Target).Magnitude());
                camera.UpVector = up;
                this.back = back;
                this.right = right;
                this.up = up;
                this.downPosition.X = x;
                this.downPosition.Y = y;
            }
        }

        public void SetBounds(int width, int height)
        {
            this.bound.Width = width;
            this.bound.Height = height;
        }

        public void MouseDown(int x, int y)
        {
            this.downPosition.X = x;
            this.downPosition.Y = y;
            this.mouseDownFlag = true;
            PrepareCamera();
        }

        private void PrepareCamera()
        {
            var camera = this.Camera;
            if (camera != null)
            {
                vec3 back = camera.Position - camera.Target;
                vec3 right = Camera.UpVector.cross(back);
                vec3 up = back.cross(right);
                back.Normalize();
                right.Normalize();
                up.Normalize();

                this.back = back;
                this.right = right;
                this.up = up;

                if (this.originalCamera == null)
                { this.originalCamera = new Camera(); }
                this.originalCamera.Position = camera.Position;
                this.originalCamera.UpVector = camera.UpVector;
            }
        }

        public void Reset()
        {
            IViewCamera camera = this.Camera;
            if (camera == null) { return; }
            IViewCamera originalCamera = this.originalCamera;
            if (originalCamera == null) { return; }

            camera.Position = originalCamera.Position;
            camera.UpVector = originalCamera.UpVector;
        }
    }

+BIT祝威+悄悄在此留下版了个权的信息说：

总结

除了本文的SatelliteRotator，还有一种称为轨迹球（AraBall）的移动Camera的方式。这里暂时就不实现了。