WisKeyのLullaby

本篇教程中，我們會鞏固上一篇所提到的矩陣和相機(jī)知識，并使用tdogl::Camera類來實(shí)現(xiàn)第一人稱射擊類型的相機(jī)。然后，我們會將相機(jī)與鍵盤和鼠標(biāo)掛鉤，使得我們可以移動和瀏覽3D場景。這里會學(xué)一些向量數(shù)學(xué)，還有上一篇沒提到的逆矩陣。

獲取代碼

所有例子代碼的zip打包可以從這里獲取：https://github.com/tomdalling/opengl-series/archive/master.zip。

這一系列文章中所使用的代碼都存放在：https://github.com/tomdalling/opengl-series。你可以在頁面中下載zip，加入你會git的話，也可以復(fù)制該倉庫。

本文代碼你可以在source/04_camera目錄里找到。使用OS X系統(tǒng)的，可以打開根目錄里的opengl-series.xcodeproj，選擇本文工程。使用Windows系統(tǒng)的，可以在Visual Studio 2013里打開opengl-series.sln，選擇相應(yīng)工程。

工程里已包含所有依賴，所以你不需要再安裝或者配置額外的東西。如果有任何編譯或運(yùn)行上的問題，請聯(lián)系我。

向量理論

在上一篇學(xué)了矩陣?yán)碚摵螅阋詾閿?shù)學(xué)理論課就結(jié)束了？想得太美了，現(xiàn)在下一部分就來了：向量。正統(tǒng)的理解認(rèn)為向量是3D編程的基礎(chǔ)。后面我會展示些代碼，是用鍵盤來進(jìn)行向量運(yùn)算，讓相機(jī)可以在不同方向上移動。

在3D中（2D中也一樣），向量經(jīng)常用來表示一些不同的東西，比如：

1. 位置（即，坐標(biāo)）
2. 位移（比如，移動）
3. 方向（比如，南北，上下）
4. 速度（比如，車的速度和方向）
5. 加速（比如，重力）

你可能注意到了上面所提的一些概念都是通常是用來實(shí)現(xiàn)物理引擎的。我們在本文中不會實(shí)現(xiàn)所有的物理，但為了更好的理解向量，第一步讓我們來一些物理教學(xué)。

什么是向量？一種偽數(shù)學(xué)的定義上來說，一個(gè)向量(vector)就是幅度(magnitude)加上方向。它能向上，向下，往左，往右，朝北，朝西南等等。你能用3D向量來表示任何一個(gè)你指向的方向。向量的另一部分，幅度，表示向量的長度或者大小。

向量最簡單的可視化方式就是繪制它，一般向量都會被繪制為箭頭。箭頭所指的方向就是向量的方向，箭頭的長度就是幅度。下面的圖是一個(gè)2D向量，但2D的理論同樣能應(yīng)用到3D上。

下面用例子來說明向量代表的不同含義。

當(dāng)編碼時(shí)，向量只是一組數(shù)字。每個(gè)數(shù)字都是向量的“一維”。比如，一個(gè)三維3D向量就是有3個(gè)數(shù)字的數(shù)組，2D向量是有2個(gè)數(shù)字。因?yàn)槲覀兪窃?D中進(jìn)行工作，所以大部分情況只要處理3D向量，但我們也需要用到4D。無論何時(shí)我說“向量”，那意味著是3D向量。我們使用GLM的向量數(shù)學(xué)庫，2D，3D，4D的類型分別為glm::vec2 ,glm::vec3,glm::vec4。

3D向量表示頂點(diǎn)，坐標(biāo)或者位置相當(dāng)簡單。3D向量的3個(gè)維度分別是X，Y，Z的值。當(dāng)向量表示位置，方向和幅度時(shí)，都是從原點(diǎn)(0,0,0)開始計(jì)算的。比如，假設(shè)一個(gè)物體的XYZ坐標(biāo)為(0,2,0)，則它的幅度是2，方向?yàn)?#8220;沿Y軸向上”。

負(fù)向量

當(dāng)你要將向量取負(fù)時(shí)，就是保持相同的幅度，但將方向變成方向。

比如：

A=向北5千米
-A=向南5千米

如果相機(jī)的方向是往右的，我們可以使用負(fù)向量來算出相機(jī)往左的方向。就像這樣：

glm::vec3 rightDirection = gCamera.right(); glm::vec3 leftDirection = -rightDirection; //vector negation 

標(biāo)量乘法

當(dāng)你將向量乘上一個(gè)數(shù)值時(shí)，新向量的結(jié)果表示相同的方向，但幅度被擴(kuò)大了相應(yīng)倍數(shù)。這個(gè)數(shù)值被稱為“標(biāo)量”，這就是為何該乘法被稱為“標(biāo)量乘法”。

比如：

A=向北5千米
0.5 × A=向北2.5千米
2 × A=向北10千米

我們可以使用標(biāo)量乘法來計(jì)算基于“移動速度”的相機(jī)位置，像這樣：

const float moveSpeed = 2.0; //units per second float distanceMoved = moveSpeed * secondsElapsed; glm::vec3 forwardDirection = gCamera.forward(); glm::vec3 displacement = distanceMoved * forwardDirection; //scalar multiplication 

向量加法

向量加法在2D圖形表現(xiàn)下最容易理解。對兩個(gè)向量進(jìn)行加法，就是將它們的頭部（箭頭一段）連接尾部（非箭頭一段）。加法順序不重要。它的結(jié)果就是，從第一個(gè)向量尾部走向另外一個(gè)向量的頭部。

注意，即使這些向量看上去是在不同的位置上，但結(jié)果向量的幅度（長度）和方向不會改變。請記住，向量只有一個(gè)方向和一個(gè)幅度。它們沒有起始點(diǎn)，所以它們可以在任意不同位置上，但還是相等的。

比如：

A = 往北1千米

B = 往西1千米

A + B = 往西北1.41千米

向量減法相當(dāng)于是加上一個(gè)負(fù)向量，比如：

A = 往北1千米

B = 往西1千米

A - B = 往西北1.41千米

A + (-B) = 往西北1.41千米

我們使用向量加法來計(jì)算出相機(jī)位移后的的新位置，像這樣：

glm::vec3 displacement = gCamera.forward() * moveSpeed * secondsElapsed; glm::vec3 oldPosition = gCamera.position(); glm::vec3 newPosition = oldPosition + displacement; //vector addition gCamera.setPosition(newPosition); 

單位向量

單位向量是幅度為1的向量。它們經(jīng)常被用來表示方向。

當(dāng)一個(gè)向量是用來表示方向時(shí)，它的幅度就沒啥用處。即使這樣，我們還是將它的幅度設(shè)為1，是為了計(jì)算時(shí)更方便一些。

當(dāng)你在單位向量上使用標(biāo)量乘法時(shí)，它的方向仍然不變，但幅度會被設(shè)為標(biāo)量的值。因此，你將一個(gè)單位向量乘上5后，新的向量的幅度就是5。假如你乘上123，那幅度也就是123。基本上這允許我們設(shè)置任意一個(gè)向量的幅度，而不會更改它的方向。

讓我們對相機(jī)進(jìn)行往左移動12單位的操作。我們先設(shè)置一個(gè)方向?yàn)樽蟮膯挝幌蛄浚缓笫褂脴?biāo)量乘法將它的幅度設(shè)為12，最后使用它來計(jì)算出新位置。代碼看上去應(yīng)該是這樣的：

// `gCamera.right()` returns a unit vector, therefore `leftDirection` will also be a unit vector. // Negation only affects the direction, not the magnitude. glm::vec3 leftDirection = -gCamera.right(); //`displacement` will have a magnitude of 12 glm::vec3 displacement = leftDirection * 12; //`newPosition` will be 12 units to the left of `oldPosition` glm::vec3 newPosition = oldPosition + displacement; 

任何一個(gè)向量都能變?yōu)閱挝幌蛄俊＿@個(gè)操作叫做單位化。我們可以用GLM來單位化一個(gè)向量：

glm::vec3 someRandomVector = glm::vec3(123,456,789); glm::vec3 unitVector = glm::normalize(someRandomVector); 

tdogl::Camera類

恭喜你看到這兒了！現(xiàn)在你已經(jīng)有足夠的向量知識了，來，讓我們開始編碼。

tdogl::Camera類的接口在這里，實(shí)現(xiàn)代碼在這里。

在前面文章中我們在OpenGL中用矩陣來實(shí)現(xiàn)相機(jī)。tdogl::Camera類可以基于各種屬性來創(chuàng)建矩陣，比如：

• 相機(jī)位置
• 相機(jī)朝向（方向）
• 縮放（視野）
• 最大和最小可視距離（遠(yuǎn)近平面）
• 視口/窗口縱橫比

上面的每個(gè)屬性都有各自的設(shè)置和獲取接口。前文已經(jīng)介紹過了。

現(xiàn)在讓我們用matrix和orientation方法來實(shí)現(xiàn)如何讓這所有屬性組合成一個(gè)矩陣。

glm::mat4 Camera::matrix() const { glm::mat4 camera = glm::perspective(_fieldOfView, _viewportAspectRatio, _nearPlane, _farPlane); camera *= orientation(); camera = glm::translate(camera, -_position); return camera; }  glm::mat4 Camera::orientation() const { glm::mat4 orientation; orientation = glm::rotate(orientation, _verticalAngle, glm::vec3(1,0,0)); orientation = glm::rotate(orientation, _horizontalAngle, glm::vec3(0,1,0)); return orientation; } 

我們可以看到，最終的相機(jī)矩陣是由四個(gè)不同的變換組成。按順序是：

• 移動，基于相機(jī)位置
• 旋轉(zhuǎn)，基于相機(jī)水平（左/右）轉(zhuǎn)角
• 旋轉(zhuǎn)，基于相機(jī)垂直（上/下）轉(zhuǎn)角
• 透視，基于視野，近平面，遠(yuǎn)平面和縱橫比

假如你覺得這順序是反的，那請記住矩陣乘法是從右往左，代碼上順序是從底往上。

注意，移動用了相機(jī)的負(fù)位置。這里再次用前文提到的方式，我們可以讓3D場景往后來實(shí)現(xiàn)相機(jī)往前走。向量為負(fù)時(shí)會反轉(zhuǎn)其方向，所以“往前”就變成“往后”。

tdogl::Camera類還有其它方法來返回單位向量：上,右和前。我們需要從鍵盤獲取消息來實(shí)現(xiàn)相機(jī)移動。

相機(jī)方位矩陣求逆

讓我來看下tdogl::Camera::up方法的實(shí)現(xiàn)，這里有兩個(gè)東西我們還沒有提及。

glm::vec3 Camera::up() const { glm::vec4 up = glm::inverse(orientation()) * glm::vec4(0,1,0,1); return glm::vec3(up); } 

我們看到它使用了glm::inverse方法。從上一篇文章中，我們知道矩陣能對坐標(biāo)進(jìn)行變換。在這里，我們還需要對坐標(biāo)進(jìn)行“反變換”，使得我們能獲得矩陣乘法變換前的坐標(biāo)。為了實(shí)現(xiàn)這個(gè)目的，我們需要計(jì)算逆矩陣。逆矩陣是一個(gè)矩陣，完全相反于另外一個(gè)矩陣，這意味著它能撤銷另外一個(gè)矩陣的變換。比如，矩陣A是繞著Y軸旋轉(zhuǎn)90°，那矩陣A的逆矩陣就是繞著Y軸旋轉(zhuǎn)-90°。

當(dāng)相機(jī)的方向改變時(shí)，“向上”的方向也隨之改變。比如，想象下有個(gè)箭頭指向你的頭頂，假如你旋轉(zhuǎn)你的頭往地上看，那箭頭就是向前傾斜，假如你往天上看，那箭頭是向后傾斜的。如果你往前看，就是你的頭“不旋轉(zhuǎn)”，那箭頭就是筆直向上。我們用“筆直向上”的單位向量(0,1,0)來表示相機(jī)的向上方向，“不旋轉(zhuǎn)”使用相機(jī)方位矩陣的逆矩陣。另外一種解釋，在相機(jī)旋轉(zhuǎn)后，向上方向總是為(0,1,0)，所以我們要將逆旋轉(zhuǎn)乘上(0,1,0)，這就能得到相機(jī)旋轉(zhuǎn)前的向上方向。

(0,1,0)是單位向量，當(dāng)你旋轉(zhuǎn)一個(gè)單位向量結(jié)果還是一個(gè)單位向量。假如結(jié)果不是單位向量，你應(yīng)該使用glm::normalize來單位化。

計(jì)算相機(jī)的前和右方向是同樣的方式。

你可能注意到了這里用了一個(gè)4D向量glm::vec4。前文解釋過，4x4 矩陣(glm::mat4)需要一個(gè)4D向量來進(jìn)行矩陣乘法，使用glm::vec3會導(dǎo)致編譯錯(cuò)誤。只要把3D向量(0,1,0)變成4D向量(0,1,0,1)就可以進(jìn)行矩陣乘法了，計(jì)算完成后我們再將4D向量變回3D向量。

整合tdogl::Camera類

現(xiàn)在我們開始使用tdogl:Camera類。

在之前的文章中，我們分別設(shè)置了投影矩陣和相機(jī)矩陣兩個(gè)著色器變量。在本文中，tdogl::Camera合并了這兩個(gè)矩陣，所以讓我們移除projection著色器變量，只用camera變量就足夠了。下面是頂點(diǎn)著色器的更新：

#version 150  uniform mat4 camera; uniform mat4 model;  in vec3 vert; in vec2 vertTexCoord;  out vec2 fragTexCoord;  void main() { // Pass the tex coord straight through to the fragment shader fragTexCoord = vertTexCoord; // Apply all matrix transformations to vert gl_Position = camera * model * vec4(vert, 1); } 

現(xiàn)在我們將tdogl::Camera整合到main.cpp中。首先包含頭文件：

#include "tdogl/Camera.h" 

然后聲明全局變量：

tdogl::Camera gCamera; 

在前一篇文章中，相機(jī)和投影矩陣是不會改變的，所以在LoadShaders函數(shù)中設(shè)置一次就好了。但在本文中，因?yàn)槲覀冃枰檬髽?biāo)和鍵盤來控制，所以設(shè)置相機(jī)矩陣要放在Render函數(shù)中并每幀都要設(shè)置一下。首先讓我們移除舊代碼：

static void LoadShaders() { std::vector<tdogl::Shader> shaders; shaders.push_back(tdogl::Shader::shaderFromFile(ResourcePath("vertex-shader.txt"), GL_VERTEX_SHADER)); shaders.push_back(tdogl::Shader::shaderFromFile(ResourcePath("fragment-shader.txt"), GL_FRAGMENT_SHADER)); gProgram = new tdogl::Program(shaders); // the commented-out code below was removed /*      gProgram->use();      //set the "projection" uniform in the vertex shader, because it's not going to change     glm::mat4 projection = glm::perspective<float>(50.0, SCREEN_SIZE.x/SCREEN_SIZE.y, 0.1, 10.0);     //glm::mat4 projection = glm::ortho<float>(-2, 2, -2, 2, 0.1, 10);     gProgram->setUniform("projection", projection);      //set the "camera" uniform in the vertex shader, because it's also not going to change     glm::mat4 camera = glm::lookAt(glm::vec3(3,3,3), glm::vec3(0,0,0), glm::vec3(0,1,0));     gProgram->setUniform("camera", camera);      gProgram->stopUsing();     */ } 

然后，在Render函數(shù)中設(shè)置camera著色器變量：

// draws a single frame static void Render() { // clear everything glClearColor(0, 0, 0, 1); // black glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // bind the program (the shaders) gProgram->use(); // set the "camera" uniform gProgram->setUniform("camera", gCamera.matrix()); 

gCamera.matrix()函數(shù)返回的是一個(gè)glm::mat4, 并且setUniform函數(shù)使用了glUniformMatrix4fv來設(shè)置頂點(diǎn)著色器中的相機(jī)矩陣uniform變量。

在AppMain函數(shù)中設(shè)置相機(jī)的初始化位置和視窗縱橫比。

gCamera.setPosition(glm::vec3(0,0,4)); gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y); 

其余相機(jī)屬性都留成默認(rèn)值。

你現(xiàn)在運(yùn)行程序，會看到上次實(shí)現(xiàn)的旋轉(zhuǎn)立方體。下一步就讓我們用鼠標(biāo)和鍵盤來控制相機(jī)。

鍵盤輸入

我們先來實(shí)現(xiàn)鍵盤控制。每次我們更新屏幕時(shí)，我們先檢查'W','A','S'或'D'按鍵是否被按下，如果有觸發(fā)那就稍微移動下相機(jī)。函數(shù)glfwGetKey返回一個(gè)布爾值來表示這個(gè)按鍵是否按下。新的Update函數(shù)看上去是這樣的：

// update the scene based on the time elapsed since last update void Update(float secondsElapsed) { //rotate the cube const GLfloat degreesPerSecond = 180.0f; gDegreesRotated += secondsElapsed * degreesPerSecond; while(gDegreesRotated > 360.0f) gDegreesRotated -= 360.0f; //move position of camera based on WASD keys const float moveSpeed = 2.0; //units per second if(glfwGetKey(gWindow, 'S')){ gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward()); } else if(glfwGetKey(gWindow, 'W')){ gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.forward()); } if(glfwGetKey(gWindow, 'A')){ gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.right()); } else if(glfwGetKey(gWindow, 'D')){ gCamera.offsetPosition(secondsElapsed * moveSpeed * gCamera.right()); } } 

我們先忽略立方體的旋轉(zhuǎn)。

當(dāng)S鍵被按下時(shí)，我們可以看得更近些：

gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward()); 

這一行代碼做了好多事，讓我們用更容易懂的方式重寫一遍，新的函數(shù)叫MoveCameraBackwards。

void MoveCameraBackwards(float secondsElapsed) { //TODO: finish writing this function } 

向后是一個(gè)方向，所以應(yīng)該是個(gè)單位向量。在相機(jī)類中沒有backward函數(shù)，但它有個(gè)forward函數(shù)。向后就是向前的反方向，所以我們只要對向前的單位向量取負(fù)數(shù)即可。

void MoveCameraBackwards(float secondsElapsed) { //`direction` is a unit vector, set to the "backwards" direction glm::vec3 direction = -gCamera.forward(); //TODO: finish writing this function } 

然后，我們應(yīng)該知道將相機(jī)移多遠(yuǎn)。我們有相機(jī)的移動速度moveSpeed，我們還知道從上一幀到現(xiàn)在過去了多少時(shí)間secondsElapsed。對這兩個(gè)值進(jìn)行乘法，就能得到相機(jī)移動的距離。

void MoveCameraBackwards(float secondsElapsed) { //`direction` is a unit vector, set to the "backwards" direction glm::vec3 direction = -gCamera.forwards(); //`distance` is the total distance to move the camera float distance = moveSpeed * secondsElapsed; //TODO: finish writing this function } 

現(xiàn)在，我們知道了移動的距離和方向，我們就能構(gòu)造一個(gè)位移向量。它的幅度就是distance，它的方向就是direction。因?yàn)?code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, 'Courier New', monospace; font-size: 13.5px; padding: 2px 4px; color: #c7254e; white-space: nowrap; border-radius: 4px; background-color: #f9f2f4;">direction是個(gè)單位向量，我們可以用標(biāo)量乘法來設(shè)置幅度。

void MoveCameraBackwards(float secondsElapsed) { //`direction` is a unit vector, set to the "backwards" direction glm::vec3 direction = -gCamera.forwards(); //vector negation //`distance` is the total distance to move the camera float distance = moveSpeed * secondsElapsed; //`displacement` is a combination of `distance` and `direction` glm::vec3 displacement = distance * direction; //scalar multiplication //TODO: finish writing this function } 

最后，我們移動（或者說是置換）相機(jī)當(dāng)前位置。用向量加法即可。最基礎(chǔ)的公式newPosition = oldPosition + displacement。

void MoveCameraBackwards(float secondsElapsed) { //`direction` is a unit vector, set to the "backwards" direction glm::vec3 direction = -gCamera.forwards(); //vector negation //`distance` is the total distance to move the camera float distance = moveSpeed * secondsElapsed; //`displacement` is a combination of `distance` and `direction` glm::vec3 displacement = distance * direction; //scalar multiplication //change the position of the camera glm::vec3 oldPosition = gCamera.position(); glm::vec3 newPosition = oldPosition + displacement; //vector addition gCamera.setPosition(newPosition); } 

完成了！MoveCameraBackwards函數(shù)這么多行代碼跟這一行代碼是一樣的：

gCamera.offsetPosition(secondsElapsed * moveSpeed * -gCamera.forward()); 

offsetPosition函數(shù)做的就是向量加法，它將位移向量作為參數(shù)傳入。讓我們使用那一行代碼來替換MoveCameraBackwards函數(shù)，因?yàn)楹啙嵕褪敲馈?/p>

其余按鍵的工作方式都是相同的，無非是方向不同而已。讓我們再添加Z和X鍵來實(shí)現(xiàn)相機(jī)上和下。

if(glfwGetKey(gWindow, 'Z')){ gCamera.offsetPosition(secondsElapsed * moveSpeed * -glm::vec3(0,1,0)); } else if(glfwGetKey(gWindow, 'X')){ gCamera.offsetPosition(secondsElapsed * moveSpeed * glm::vec3(0,1,0)); } 

注意，為什么這里用向量(0,1,0)而不是gCamera.up()。記住，“向上”方向會隨著相機(jī)方向而改變。假如相機(jī)看地上，“向上”指的是向前，假設(shè)相機(jī)看天上，“向上”指的是向后。這并不是我想實(shí)現(xiàn)的行為，我希望的是“筆直向上”的方向(0,1,0)，不依賴于相機(jī)的方向。

現(xiàn)在當(dāng)你運(yùn)行程序，你能使用W, A, S, D, X,和Z鍵來向前移動，向左移動，向后移動，向右移動，向上移動和向下移動。觀察時(shí)不會因?yàn)橄鄼C(jī)移動而改變方向，這個(gè)將留個(gè)鼠標(biāo)來控制。

鼠標(biāo)輸入

此時(shí)，我們的窗口還無法捕捉鼠標(biāo)消息。你能看到鼠標(biāo)在窗口上移來移去。我希望它消失，并且不希望它移出窗口。為了實(shí)現(xiàn)這個(gè)，我們要改下GLFW的設(shè)置。

在我們捕獲鼠標(biāo)之前，讓我們先實(shí)現(xiàn)用取消鍵（Esc）退出程序。我不想再點(diǎn)擊關(guān)閉按鈕了，因?yàn)槭髽?biāo)隱藏，并且無法離開窗口。讓我們在AppMain主循環(huán)下放加上些代碼：

// run while the window is open double lastTime = glfwGetTime(); while(!glfwWindowShouldClose(gWindow)){ // process pending events glfwPollEvents(); // update the scene based on the time elapsed since last update double thisTime = glfwGetTime(); Update((float)(thisTime - lastTime)); lastTime = thisTime; // draw one frame Render(); // check for errors GLenum error = glGetError(); if(error != GL_NO_ERROR) std::cerr << "OpenGL Error " << error << std::endl; //exit program if escape key is pressed if(glfwGetKey(gWindow, GLFW_KEY_ESCAPE)) glfwSetWindowShouldClose(gWindow, GL_TRUE); } 

當(dāng)我們用glfwCreateWindow打開窗口這樣設(shè)置時(shí)，就可以捕獲鼠標(biāo)了：

// GLFW settings glfwSetInputMode(gWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glfwSetCursorPos(gWindow, 0, 0); 

這段代碼讓鼠標(biāo)消失了，并且將它移動到了像素坐標(biāo)(0,0)。在Update中，我們會獲取鼠標(biāo)位置來更新相機(jī)，更新完后將鼠標(biāo)坐標(biāo)再次設(shè)為(0,0)。這種方式可以很方便的看出每幀鼠標(biāo)移動了多少，還要在當(dāng)鼠標(biāo)要移出窗口時(shí)停住它。在Update函數(shù)下面添加以下代碼：

//rotate camera based on mouse movement const float mouseSensitivity = 0.1f; double mouseX, mouseY; glfwGetCursorPos(gWindow, &mouseX, &mouseY); gCamera.offsetOrientation(mouseSensitivity * (float)mouseY, mouseSensitivity * (float)mouseX); glfwSetCursorPos(gWindow, 0, 0); //reset the mouse, so it doesn't go out of the window 

鼠標(biāo)的坐標(biāo)單位是像素，但相機(jī)方向是基于兩個(gè)角度。這就是為何我們使用mouseSensitivity變量來將像素轉(zhuǎn)為角度。越大的鼠標(biāo)靈敏度，相機(jī)轉(zhuǎn)向的越快，越小的靈敏度，轉(zhuǎn)向的越慢。靈敏度設(shè)為0.1f的含義就是每10像素就旋轉(zhuǎn)1°。

offsetOrientation函數(shù)類似于offsetPosition函數(shù)，它會使用水平和垂直角度來更新相機(jī)方向。

好了！基本到這就完成了。你現(xiàn)在運(yùn)行程序的話，你能繞著飛行并且幾乎能觀察任意方向。立方體的旋轉(zhuǎn)動畫可能會讓你在環(huán)繞時(shí)失去方向感，我們可以關(guān)閉它。

用鼠標(biāo)滾輪控制視野

就像蛋糕上的糖衣一樣，我們可以滾動鼠標(biāo)或者在觸摸板上滑動來實(shí)現(xiàn)相機(jī)鏡頭的視野縮放。上篇文章我們已經(jīng)解釋過視野的概念了。

我們使用同樣的方式來使用鼠標(biāo)位置，并且每幀重置滾動值。首先我們創(chuàng)建一個(gè)全局變量來保存滾動值：

double gScrollY = 0.0; 

使用GLFW來接受滾輪消息，首先我們得創(chuàng)建個(gè)回調(diào)：

// records how far the y axis has been scrolled void OnScroll(GLFWwindow* window, double deltaX, double deltaY) { gScrollY += deltaY; } 

然后我們用GLFW在AppMain中注冊下回調(diào)：

glfwSetScrollCallback(gWindow, OnScroll); 

當(dāng)每幀我們渲染的時(shí)候，我們使用gScrollY值來更改視野。代碼放在Update函數(shù)的下放：

const float zoomSensitivity = -0.2f; float fieldOfView = gCamera.fieldOfView() + zoomSensitivity * (float)gScrollY; if(fieldOfView < 5.0f) fieldOfView = 5.0f; if(fieldOfView > 130.0f) fieldOfView = 130.0f; gCamera.setFieldOfView(fieldOfView); gScrollY = 0; 

zoomSensitivity常量類似mouseSensitivity常量。視野取值范圍是0°到180°，但假如你設(shè)置的值離上下限很近的話，3D場景看上去會很奇怪，所以我們限制這個(gè)值范圍在5°到130°。類似鼠標(biāo)位置的方法，我們在每幀之后設(shè)置gScrollY = 0。

下篇預(yù)告

下一篇文章，我們會重構(gòu)代碼來實(shí)現(xiàn)最最基本的“引擎”。我們會將代碼分為資產(chǎn)（資源）和實(shí)例，類似典型的3D引擎，可以生成有多個(gè)略微不同的木箱子的3D場景。

更多資源

• The vector math chapter of Learning Modern 3D Graphics Programming by Jason L. McKesson
• Vector maths – a primer for games programmers
• Basic 3D Math: Vectors by Egon Rath
• Wikipedia article on vectors, which isn't very beginner-friendly
• The GLFW guides and references.
• 假如你有任何關(guān)于向量方面對初學(xué)者友好的文章，請發(fā)送給我，我會添加進(jìn)來。