SharpGL學習筆記(十九) 攝像機漫游

 

所謂的攝像機漫游，就是可以在場景中來回走動。

現實中，我們通過眼睛觀察東西，身體移動帶動眼睛移動觀察身邊的事物，這也是在漫游。

在OpenGL中我們使用函數LookAt()來操作攝像機在三維場景中進行漫游。

 LookAt(double eyex, double eyey, double eyez, double centerx, double centery, double centerz, double upx, double upy, double upz);

 

我們通過改變LookAt的參數實現漫游效果，說明如下：

• 改變視點eyeX，可以實現在場景中橫向移動
• 改變視點eyeY，可以實現在場景中蹲下，跳起這樣的動作
• 改變視點Z分量eyeZ，能實現在場景中前后的動作
• 對於攝像機目標點centerx,y,z 的變化，相當於觀察者站着不動，但其觀察方向在上下左右方向進行變化。

 效果縮略圖：

 

 源代碼：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using SharpGL;
using System.Runtime.InteropServices;

namespace cameraRove
{
    //原創文章,出自"博客園, 豬悟能'S博客" : http://www.cnblogs.com/hackpig/
    public partial class SharpGLForm : Form
    {
        SharpGL.SceneGraph.Assets.Texture texture = new SharpGL.SceneGraph.Assets.Texture();
        Camera m_Camera = new Camera();

        //光源位置 
        float lx = 2f;
        float ly = 1f;
        float lz = 9f;

        float[] fLightPosition = new float[4];// 光源位置 
        float[] fLightAmbient = new float[4] { 1f, 1f, 1f, 1.0f };// 環境光參數 
        float[] fLightDiffuse = new float[4] { 1f, 1f, 1f, 1f };// 漫射光參數


        public SharpGLForm()
        {
            InitializeComponent();
        }

        private void openGLControl_OpenGLDraw(object sender, PaintEventArgs e)
        {
            OpenGL gl = openGLControl.OpenGL;
            gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
            gl.LoadIdentity();

            gl.DrawText(20,this.Height-60, 1f, 1f, 1f, "黑體", 12f, string.Format(
              "當前位置:X={0}  Y={1} Speed ={2} ", m_Camera.getView().x.ToString("0.0"),
              (-m_Camera.getView().z).ToString("0.0"), m_Camera.getSpeed()));

            
            m_Camera.setLook(gl);

            drawBox(gl, 1f, 1f, 0f);

            m_Camera.setViewByMouse();
        }


        void drawGrid(OpenGL gl)
        {
            //獲得場景中一些狀態
            byte[] lp = new byte[] { 0, 0 };
            byte[] tp = new byte[] { 0, 0 };
            gl.GetBooleanv(OpenGL.GL_LIGHTING, lp);
            gl.GetBooleanv(OpenGL.GL_TEXTURE_2D, tp);

            //關閉紋理和光照
            gl.Disable(OpenGL.GL_TEXTURE_2D);
            gl.Disable(OpenGL.GL_LIGHTING);

            //繪制過程
            gl.PushAttrib(OpenGL.GL_CURRENT_BIT);  //保存當前屬性
            gl.PushMatrix();                        //壓入堆棧
            gl.Translate(0f, 0f, 0f);
            gl.Color(0f, 0f, 1f);

            //在X,Z平面上繪制網格
            for (float i = -50; i <= 50; i += 1)
            {
                //繪制線
                gl.Begin(OpenGL.GL_LINES);
                //X軸方向
                gl.Vertex(-50f, 0f, i);
                gl.Vertex(50f, 0f, i);
                //Z軸方向 
                gl.Vertex(i, 0f, -50f);
                gl.Vertex(i, 0f, 50f);
                gl.End();
            }
            gl.PopMatrix();
            gl.PopAttrib();

            //恢復場景狀態
            if (tp[0] != 0)
                gl.Enable(OpenGL.GL_TEXTURE_2D);
            if (lp[0] != 0)
                gl.Enable(OpenGL.GL_LIGHTING);
        }

        void drawSphere(OpenGL gl)
        {
            //設置材質屬性
            float[] mat_ambient = { 0.9f, 0.5f, 0.8f, 1.0f };
            float[] mat_diffuse = { 0.9f, 0.5f, 0.8f, 1.0f };
            float[] mat_shininess = { 100.0f };
            gl.Material(OpenGL.GL_FRONT, OpenGL.GL_AMBIENT, mat_ambient);
            gl.Material(OpenGL.GL_FRONT, OpenGL.GL_DIFFUSE, mat_diffuse);
            gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SHININESS, mat_shininess);

            //獲得紋理啟用狀態
            byte[] tp = { 0, 0 };
            gl.GetBooleanv(OpenGL.GL_TEXTURE_2D, tp);
            gl.Disable(OpenGL.GL_TEXTURE_2D);           //關閉紋理

            //繪制過程
            gl.PushMatrix();
            gl.Translate(2f, 1f, 5f);
            var sphere= gl.NewQuadric();
            gl.QuadricNormals(sphere, OpenGL.GLU_OUTSIDE);
            gl.QuadricNormals(sphere, OpenGL.GLU_SMOOTH);
            gl.Sphere(sphere, 1f, 50, 50);
            gl.DeleteQuadric(sphere);
            gl.PopMatrix();

            if (tp[0] != 0)
                gl.Enable(OpenGL.GL_TEXTURE_2D);
        }

        private void drawBox(OpenGL gl, float xPos, float yPos, float zPos)
        {
            gl.PushMatrix();
            texture.Bind(gl);
            gl.Scale(2, 3, 2);
            gl.Translate(xPos, yPos, zPos);
            gl.Begin(OpenGL.GL_QUADS);
            {
                //前
                gl.TexCoord(0, 0); gl.Vertex(0, 0, 0);
                gl.TexCoord(1, 0); gl.Vertex(-1, 0, 0);
                gl.TexCoord(1, 1); gl.Vertex(-1, -1, 0);
                gl.TexCoord(0, 1); gl.Vertex(0, -1, 0);

                //底
                gl.TexCoord(0, 0); gl.Vertex(0, 0, 0);
                gl.TexCoord(1, 0); gl.Vertex(0, 0, -1);
                gl.TexCoord(1, 1); gl.Vertex(-1, 0, -1);
                gl.TexCoord(0, 1); gl.Vertex(-1, 0, 0);

                //左
                gl.TexCoord(0, 0); gl.Vertex(-1, 0, 0);
                gl.TexCoord(1, 0); gl.Vertex(-1, 0, -1);
                gl.TexCoord(1, 1); gl.Vertex(-1, -1, -1);
                gl.TexCoord(0, 1); gl.Vertex(-1, -1, 0);

                //右
                gl.TexCoord(0, 0); gl.Vertex(0, 0, 0);
                gl.TexCoord(1, 0); gl.Vertex(0, 0, -1);
                gl.TexCoord(1, 1); gl.Vertex(0, -1, -1);
                gl.TexCoord(0, 1); gl.Vertex(0, -1, 0);

                //后
                gl.TexCoord(0, 0); gl.Vertex(0, 0, -1);
                gl.TexCoord(1, 0); gl.Vertex(-1, 0, -1);
                gl.TexCoord(1, 1); gl.Vertex(-1, -1, -1);
                gl.TexCoord(0, 1); gl.Vertex(0, -1, -1);

                //頂
                gl.TexCoord(0, 0); gl.Vertex(0, -1, 0);
                gl.TexCoord(1, 0); gl.Vertex(0, -1, -1);
                gl.TexCoord(1, 1); gl.Vertex(-1, -1, -1);
                gl.TexCoord(0, 1); gl.Vertex(-1, -1, 0);
            }
            gl.End();

            gl.PopMatrix();
            drawGrid(gl);
            drawSphere(gl);
        }

        private void openGLControl_OpenGLInitialized(object sender, EventArgs e)
        {
            OpenGL gl = openGLControl.OpenGL;
            texture.Create(gl, "image.bmp");
            gl.Enable(OpenGL.GL_TEXTURE_2D);

            fLightPosition = new float[4] { lx, ly, lz, 1f };
            gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_AMBIENT, fLightAmbient);//環境光源 
            gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, fLightDiffuse);//漫射光源 
            gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_POSITION, fLightPosition);//光源位置 
            gl.Enable(OpenGL.GL_LIGHTING);//開啟光照 
            gl.Enable(OpenGL.GL_LIGHT0);

            gl.Enable(OpenGL.GL_NORMALIZE);

            gl.ClearColor(0, 0, 0, 0);

            m_Camera.setCamera(0.0f, 1.5f, 6.0f, 0.0f, 1.5f, 0.0f, 0.0f, 1.0f, 0.0f);
            m_Camera.setSpeed(1f);

        }

        private void openGLControl_Resized(object sender, EventArgs e)
        {
            OpenGL gl = openGLControl.OpenGL;
            gl.MatrixMode(OpenGL.GL_PROJECTION);
            gl.LoadIdentity();
            gl.Perspective(60.0f, (double)Width / (double)Height, 0.01, 100.0);
            gl.LookAt(-6, 1, 0, 0, 0, 0, 0, 1, 0);
            gl.MatrixMode(OpenGL.GL_MODELVIEW);
        }

        private void openGLControl_KeyDown(object sender, KeyEventArgs e)
        {
          
            switch (e.KeyCode)
            {
                case Keys.W:   //上
                    m_Camera.yawCamera(m_Camera.getSpeed());
                    
                    break;
                case Keys.S:   //下
                    m_Camera.yawCamera(-m_Camera.getSpeed());
                   
                    break;
                case Keys.A:   //左
                    m_Camera.moveCamera(m_Camera.getSpeed());
                    break;
                case Keys.D:   //右
                    m_Camera.moveCamera(-m_Camera.getSpeed());
                   
                    break;
                default:
                    break;
            }
        }


    }

    
    class Camera
    {
        private Vector3 m_Position;     //位置
        private Vector3 m_View;         //朝向
        private Vector3 m_UpVector;     //向上向量
        private float m_Speed;          //速度

        public Camera()
        {
            Vector3 zero =new Vector3(0f, 0f, 0f);
            Vector3 view =new Vector3(0f, 1f, 0.5f);
            Vector3 up =new Vector3(0f, 0f, 1f);
            m_Position = zero;
            m_View = view;
            m_UpVector = up;
            m_Speed = 0.1f;
        }

        public void setSpeed(float speed)
        {
            m_Speed = speed;
        }

        public float getSpeed()
        {
            return m_Speed;
        }

        public Vector3 getPosition()
        {
            return m_Position;
        }

        public Vector3 getView()
        {
            return m_View;
        }

        public Vector3 getUpVector()
        {
            return m_UpVector;
        }


        //設置攝像機的位置,朝向和向上向量
        public void setCamera(float positionX,float positionY,
            float positionZ, float viewX,float viewY,
            float viewZ,float upVectorX,float upVectorY,
            float upVectorZ)
        {
            //構造向量
            Vector3 Position =new Vector3(positionX, positionY, positionZ);
            Vector3 View = new Vector3(viewX, viewY, viewZ);
            Vector3 UpVector = new Vector3(upVectorX, upVectorY, upVectorZ);

            //設置攝像機
            m_Position = Position;
            m_View = View;
            m_UpVector = UpVector;
        }

        //旋轉攝像機方向
        void rotateView(float angle, float x, float y, float z)
        {
            Vector3 newView=new Vector3();
            //計算方向向量
            Vector3 view = m_View - m_Position;
            //計算 sin 和cos值 
            float cosTheta =(float) Math.Cos(angle);
            float sinTheta = (float)Math.Sin(angle);

            //計算旋轉向量的x值
            newView.x = (cosTheta + (1 - cosTheta) * x * x) * view.x;
            newView.x += ((1 - cosTheta) * x * y - z * sinTheta) * view.y;
            newView.x += ((1 - cosTheta) * x * z + y * sinTheta) * view.z;

            //計算旋轉向量的y值
            newView.y = ((1 - cosTheta) * x * y + z * sinTheta) * view.x;
            newView.y += (cosTheta + (1 - cosTheta) * y * y) * view.y;
            newView.y += ((1 - cosTheta) * y * z - x * sinTheta) * view.z;

            //計算旋轉向量的y值
            newView.z = ((1 - cosTheta) * x * z - y * sinTheta) * view.x;
            newView.z += ((1 - cosTheta) * y * z + x * sinTheta) * view.y;
            newView.z += (cosTheta + (1 - cosTheta) * z * z) * view.z;

            //更新攝像機的方向
            m_View = m_Position + newView;
        }


        [DllImport("user32.dll", EntryPoint = "GetSystemMetrics")]
        public static extern int GetSystemMetrics(int which);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern bool GetCursorPos(out Point pt);

        [DllImport("user32.dll", EntryPoint = "ShowCursor", CharSet = CharSet.Auto)]
        public extern static void ShowCursor(int status);

        [DllImport("user32.dll", EntryPoint = "SetCursorPos")]
        private static extern int SetCursorPos(int x, int y);

        float lastRotX = 0.0f;      // 用於保存旋轉角度
        float currentRotX = 0.0f;
        public void setViewByMouse()
        {
            const int SM_CXSCREEN = 0;
            const int SM_CYSCREEN = 1;
            Point mousePos;                                      /**< 保存當前鼠標位置 */
            int middleX = GetSystemMetrics(SM_CXSCREEN) >> 1; /**< 得到屏幕寬度的一半 */
            int middleY = GetSystemMetrics(SM_CYSCREEN) >> 1; /**< 得到屏幕高度的一半 */
            float angleY = 0.0f;                              /**< 攝像機左右旋轉角度 */
            float angleZ = 0.0f;                              /**< 攝像機上下旋轉角度 */


            // 得到當前鼠標位置
            GetCursorPos(out mousePos);
            ShowCursor(0);

            // 如果鼠標沒有移動,則不用更新
            if ((mousePos.X == middleX) && (mousePos.Y == middleY))
                return;

            // 設置鼠標位置在屏幕中心
            SetCursorPos(middleX, middleY);

            // 得到鼠標移動方向
            angleY = (float)((middleX - mousePos.X)) / 1000.0f;
            angleZ = (float)((middleY - mousePos.Y)) / 1000.0f;

            lastRotX = currentRotX;

            // 跟蹤攝像機上下旋轉角度 
            currentRotX += angleZ;

            // 如果上下旋轉弧度大於1.0,我們截取到1.0並旋轉
            if (currentRotX > 1.0f)
            {
                currentRotX = 1.0f;

                // 根據保存的角度旋轉方向
                if (lastRotX != 1.0f)
                {
                    // 通過叉積找到與旋轉方向垂直的向量
                    Vector3 vAxis = m_View - m_Position;
                    vAxis = vAxis.crossProduct(m_UpVector);
                    vAxis = vAxis.normalize();

                    ///旋轉
                    rotateView(1.0f - lastRotX, vAxis.x, vAxis.y, vAxis.z);
                }
            }
            // 如果旋轉弧度小於-1.0,則也截取到-1.0並旋轉
            else if (currentRotX < -1.0f)
            {
                currentRotX = -1.0f;
                if (lastRotX != -1.0f)
                {

                    // 通過叉積找到與旋轉方向垂直的向量
                    Vector3 vAxis = m_View - m_Position;
                    vAxis = vAxis.crossProduct(m_UpVector);
                    vAxis = vAxis.normalize();

                    rotateView(-1.0f - lastRotX, vAxis.x, vAxis.y, vAxis.z);
                }
            }
            // 否則就旋轉angleZ度
            else
            {
                // 找到與旋轉方向垂直向量
                Vector3 vAxis = m_View - m_Position;
                vAxis = vAxis.crossProduct(m_UpVector);
                vAxis = vAxis.normalize();

                rotateView(angleZ, vAxis.x, vAxis.y, vAxis.z);
            }

            // 總是左右旋轉攝像機
            rotateView(angleY, 0, 1, 0);
        }





        public void yawCamera(float speed)
        {
            Vector3 yaw = new Vector3();
            Vector3 cross = m_View - m_Position;
            cross = cross.crossProduct(m_UpVector);

            //歸一化向量
            yaw = cross.normalize();

            m_Position.x += yaw.x * speed;
            m_Position.z += yaw.z * speed;

            m_View.x += yaw.x * speed;
            m_View.z += yaw.z * speed;
        }

        public void moveCamera(float speed)
        {
            //計算方向向量
            Vector3 vector = m_View - m_Position;
            vector = vector.normalize();    //單位化

            //更新攝像機
            m_Position.x += vector.x * speed;   //根據速度更新位置
            m_Position.z += vector.z * speed;
            m_Position.y += vector.y * speed;

            m_View.x += vector.x * speed;       //根據速度更新方向
            m_View.y += vector.y * speed;
            m_View.z += vector.z * speed;
        }

        //設置視點
        public void setLook(OpenGL gl)
        {
            gl.LookAt(m_Position.x, m_Position.y, m_Position.z,
                m_View.x, m_View.y, m_View.z,
                m_UpVector.x, m_UpVector.y, m_UpVector.z);
        }
    }


    //向量運算類
    class Vector3
    {
        public float x, y, z;
        public Vector3()
        {
            x = 0; y = 0; z = 0;
        }

        public Vector3(float x, float y, float z)
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public Vector3(Vector3 vec)
        {
            this.x = vec.x;
            this.y = vec.y;
            this.z = vec.z;
        }

        public float length()
        {
            return (float)(x * x + y * y + z * z);
        }

        public Vector3 normalize()
        {
            float len = length();
            if (len == 0) len = 1;
            x = x / len;
            y = y / len;
            z = z / len;
            return this;
        }

        //點積
        public float dotProduct(Vector3 vec)
        {
            return 0f;
        }

        public Vector3 crossProduct(Vector3 vec)
        {
            Vector3 v = new Vector3();
            v.x = y * vec.z - z * vec.y;
            v.y = z * vec.x - x * vec.z;
            v.z = x * vec.y - y * vec.x;
            return v;
        }

        public static Vector3 operator +(Vector3 v1,Vector3 v2)
        {
            var res = new Vector3();
            res.x=v1.x+v2.x;
            res.y=v1.y+v2.y;
            res.z=v1.z+v2.z;
            return res;
        }

        public static Vector3 operator -(Vector3 v1,Vector3 v2)
        {
            var res = new Vector3();
            res.x=v1.x-v2.x;
            res.y=v1.y-v2.y;
            res.z=v1.z-v2.z;
            return res;
        }

        public static Vector3 operator *(Vector3 v1, Vector3 v2)
        {
            var res = new Vector3();
            res.x = v1.x * v2.x;
            res.y = v1.y * v2.y;
            res.z = v1.z * v2.z;
            return res;
        }

        public static Vector3 operator /(Vector3 v1, Vector3 v2)
        {
            var res = new Vector3();
            res.x = v1.x / v2.x;
            res.y = v1.y / v2.y;
            res.z = v1.z / v2.z;
            return res;
        }

        public static Vector3 operator -(Vector3 vec)
        {
            vec.x=-1*vec.x;
            vec.y=-1*vec.y;
            vec.z=-1*vec.z;
            return vec;
        }

    }

}

 

 

 

效果如下圖：

移動鼠標可以旋轉攝像機，按鍵盤的WASD四個鍵可以XY方向移動攝像機。

 

 

本例子改編自徐明亮《OpenGL游戲編程》一書中“攝像機漫游” 一章節。

通過這個例子，發現了一個讓筆者不解的問題。為什么我辦公電腦那種垃圾配置（雙核2G，集成顯卡）跑這個例子比較快，但我家里的電腦（四核，顯卡是geForce GTX 750Ti) 運行起來卻蠻慢？

貌似根本就沒有發揮強大顯卡的性能嘛！

還有，VC6寫的實現同樣效果的程序要跑得快些哦！這又是昨回事？ 這擺明讓人羡慕嫉妒恨嘛！

 

補充一點：這個程序請按Alt+F4退出．

 

本節源代碼下載

 

原創文章,出自"博客園, 豬悟能'S博客" : http://www.cnblogs.com/hackpig/