前面已经建立了 OpenGL 框架，加载了 3D 模型，但是还没有在场景中漫游的功能。为了展示 3D 模型，我只是简单地利用变换视图矩阵的方式使模型在视野中旋转。同时，之前的程序连最简单的改变窗口大小的功能都没有，不能放大窗口而观察模型的更多细节。从这一节开始，我要实现在场景中漫游的功能。

功能的设计很简单，就像所有的 FPS 游戏一样，按A W S D进行前进后退和左右移动，使用鼠标控制方向，为了简单起见，暂时只考虑左右转动，不实现上下转动的功能。

改变窗口大小的功能很简单，添加一个 static 的 onWindowSize() 函数就可以了，然后调用 glfwSetWindowSizeCallback() 注册这个回调函数。添加这个功能后，我们就可以把窗口放大到全屏了，如下图：

前面一直使用的是线框模型，这里可以设置按M键来切换线框模式和填充模式。这里可以先编写一个 onKey() 方法，然后使用 glfwSetSetKeyCallback() 来设置回调。

这时不能使用 glfwSetSetKeyCallback() 来设置回调，因为 onKey() 方法只在每次按键的时候调用一次，即使按着键不动，它也不会连续调用，不符合我们的要求。这时，需要在每一帧的绘图函数里面调用 processInput() 方法，并在 processInput() 方法里面调用 glfwGetKey() 来实现这个效果。

另外，我们的视图矩阵要改了。我们可以在 App 类里面设置三个变量，cameraPosition、cameraFront、cameraUp，分别代表摄像机的位置、前方、上方，然后使用 GLM 的 lookAt() 函数来设置视图矩阵。

根据 3D 场景的复杂程度不同，其渲染速度也会不同，为了保证我们移动速度的一致性，我这里顺便搞一个计算帧率的功能。

使用 GLFW 的鼠标回调函数，可以很方便地得到鼠标的 X 坐标和 Y 坐标，因此实现左右转动视角的功能非常方便。我没有使用很复杂的三角函数计算，只是利用 GLM 的 rotate() 函数对 cameraFront 向量进行旋转就可以了。我们还可以充分利用 GLFW 捕获鼠标功能，设计为在窗口中点击鼠标后捕获鼠标指针，按ESC键后释放鼠标捕获，只有在捕获鼠标指针的状态下才能够左右旋转视角。这时主要用到的 API 是 glfwSetCursorPosCallback() 和 glfwSetMouseButtonCallback()。

经过修改后的 app.hpp 完整代码如下：

  1. #ifndef __APP_HPP__
  2. #define __APP_HPP__
  4. #include <GL/glew.h>
  5. #include <GLFW/glfw3.h>
  6. #include <iostream>
  7. #include <glm/glm.hpp>
  8. #include <glm/gtc/matrix_transform.hpp>
  10. class App
  11. {
  12. private:
  13.     const int SCR_WIDTH = 1920;
  14.     const int SCR_HEIGHT = 1080;
  16. public:
  17.     static App *the_app;
  18.     float aspect;
  19.     glm::vec3 cameraPosition;
  20.     glm::vec3 cameraFront;
  21.     glm::vec3 cameraUp;
  22.     float cameraSpeed;
  23.     double timeLastFrame;
  24.     double timeThisFrame;
  25.     double timeAccumulate;
  26.     int countFrames;
  27.     bool showFps;
  28.     bool firstMouse;
  29.     double lastX;
  30.     bool captureCursor;
  32.     App()
  33.     {
  34.         aspect = (float)SCR_WIDTH / (float)SCR_HEIGHT;
  35.         cameraPosition = glm::vec3(0.0f, 0.0f, 0.0f);
  36.         cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
  37.         cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
  38.         firstMouse = true;
  39.     }
  41.     static void onWindowSize(GLFWwindow *window, int width, int height)
  42.     {
  43.         glViewport(0, 0, width, height);
  44.         the_app->aspect = (float)width / (float)height;
  45.     }
  47.     static void onKey(GLFWwindow *window, int key, int scancode, int action, int mods)
  48.     {
  49.         if (action == GLFW_PRESS)
  50.         {
  51.             switch (key)
  52.             {
  53.             case GLFW_KEY_M: //切换线框模式和填充模式
  54.             {
  55.                 static GLenum mode = GL_FILL;
  56.                 mode = (mode == GL_FILL ? GL_LINE : GL_FILL);
  57.                 glPolygonMode(GL_FRONT_AND_BACK, mode);
  58.                 return;
  59.             }
  60.             case GLFW_KEY_ESCAPE: //停止鼠标捕获，主要是应付鼠标被捕获的情况
  61.             {
  62.                 if (the_app->captureCursor)
  63.                 {
  64.                     glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
  65.                     the_app->captureCursor = false;
  66.                 }
  68.                 return;
  69.             }
  70.             case GLFW_KEY_F: //打开和关闭输出fps的功能，输出到控制台
  71.             {
  72.                 the_app->showFps = (the_app->showFps == false ? true : false);
  73.                 return;
  74.             }
  75.             }
  76.         }
  77.     }
  79.     virtual void processInput(GLFWwindow *window)
  80.     {
  81.         if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
  82.         {
  83.             cameraPosition += cameraSpeed * cameraFront;
  84.         }
  85.         if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
  86.         {
  87.             cameraPosition -= cameraSpeed * cameraFront;
  88.         }
  89.         if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
  90.         {
  91.             cameraPosition += cameraSpeed * glm::normalize(glm::cross(cameraFront, cameraUp));
  92.         }
  93.         if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
  94.         {
  95.             cameraPosition -= cameraSpeed * glm::normalize(glm::cross(cameraFront, cameraUp));
  96.         }
  97.     }
  99.     static void onMouseMove(GLFWwindow *window, double xpos, double ypos)
  100.     {
  101.         //std::cout << "xpos:" << xpos << "   ypos:" << ypos << std::endl;
  102.         if (!the_app->captureCursor)
  103.         {
  104.             return;
  105.         }
  106.         if (the_app->firstMouse)
  107.         {
  108.             the_app->lastX = xpos;
  109.             the_app->firstMouse = false;
  110.             return;
  111.         }
  112.         double xoffset = xpos - the_app->lastX;
  113.         the_app->lastX = xpos;
  115.         double sensitivity = 0.005f; //灵敏度
  116.         xoffset *= sensitivity;
  118.         glm::mat4 I(1.0f);
  119.         glm::vec3 Y(0.0f, 1.0f, 0.0f);
  121.         the_app->cameraFront = glm::vec3(glm::vec4(the_app->cameraFront, 1.0f) * glm::rotate(I, (float)xoffset, Y));
  122.     }
  124.     static void onMouseButton(GLFWwindow *window, int button, int action, int mods)
  125.     {
  126.         if (action == GLFW_PRESS)
  127.         {
  128.             switch (button)
  129.             {
  130.             case GLFW_MOUSE_BUTTON_LEFT:
  131.                 glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
  132.                 the_app->captureCursor = true;
  133.                 return;
  134.             }
  135.         }
  136.     }
  138.     virtual void init()
  139.     {
  140.     }
  142.     virtual void display()
  143.     {
  144.     }
  146.     virtual void run(App *app)
  147.     {
  148.         if (the_app != NULL)
  149.         { //同一时刻，只能有一个App运行
  150.             std::cerr << "The the_app is already run." << std::endl;
  151.             return;
  152.         }
  153.         the_app = app;
  155.         glfwInit();
  156.         GLFWwindow *window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "StudyOpenGL", NULL, NULL);
  157.         if (window == NULL)
  158.         {
  159.             std::cerr << "Failed to create GLFW window" << std::endl;
  160.             glfwTerminate();
  161.             return;
  162.         }
  163.         glfwMakeContextCurrent(window);
  164.         glfwSetWindowSizeCallback(window, onWindowSize);
  165.         glfwSetKeyCallback(window, onKey);
  166.         glfwSetCursorPosCallback(window, onMouseMove);
  167.         glfwSetMouseButtonCallback(window, onMouseButton);
  168.         if (glewInit() != GLEW_OK)
  169.         {
  170.             std::cerr << "Failed to initalize GLEW" << std::endl;
  171.             return;
  172.         }
  174.         init(); //Init主要是用来创建VAO、VBO等，并准备要各种数据
  176.         while (!glfwWindowShouldClose(window))
  177.         {
  178.             display(); //这里才是渲染图形的主战场
  180.             timeThisFrame = glfwGetTime();
  182.             //记录帧渲染之后的时间，并计算帧率，如果输出帧率，则每一秒输出一次（主要是标准输出太慢）,同时计算cameraSpeed;
  183.             double timeInterval = timeThisFrame - timeLastFrame;
  184.             timeLastFrame = timeThisFrame;
  185.             if (showFps)
  186.             {
  187.                 if (timeAccumulate < 1.0)
  188.                 {
  189.                     countFrames++;
  190.                     timeAccumulate += timeInterval;
  191.                 }
  192.                 else
  193.                 {
  194.                     std::cout << "FPS: " << countFrames << std::endl;
  195.                     countFrames = 0;
  196.                     timeAccumulate = 0;
  197.                 }
  198.             }
  199.             cameraSpeed = 2.5f * (float)timeInterval;
  201.             glfwSwapBuffers(window);
  202.             processInput(window);
  203.             glfwPollEvents();
  204.         }
  205.         glfwDestroyWindow(window);
  207.         glfwTerminate();
  208.         return;
  209.     }
  210. };
  212. App *App::the_app = NULL;
  214. #define DECLARE_MAIN(a)                   \
  215.     int main(int argc, const char **argv) \
  216.     {                                     \
  217.         a *app = new a;                   \
  218.         app->run(app);                    \
  219.         delete app;                       \
  220.         return 0;                         \
  221.     }
  223. #endif

然后，我们的 WanderInScene.cpp 的完整内容如下：

  1. #include "../include/app.hpp"
  2. #include "../include/shader.hpp"
  3. #include "../include/model.hpp"
  4. #include <glm/glm.hpp>
  5. #include <glm/gtc/matrix_transform.hpp>
  7. class MyApp : public App {
  8.     private:
  9.         const GLfloat clearColor[4] = {0.2f, 0.3f, 0.3f, 1.0f};
  10.         Model lita;
  11.         Shader* simpleShader;
  13.     public:
  14.         void init(){
  15.             
  16.             ShaderInfo shaders[] = {
  17.                 {GL_VERTEX_SHADER, "simpleShader.vert"},
  18.                 {GL_FRAGMENT_SHADER, "simpleShader.frag"},
  19.                 {GL_NONE, ""}
  20.             };
  21.             simpleShader = new Shader(shaders);
  22.             lita.loadModel("lita.obj");
  23.           
  24.             glEnable(GL_DEPTH_TEST);
  25.             glDepthFunc(GL_LEQUAL);
  27.             glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
  28.         }
  30.         void display(){
  31.             glClearBufferfv(GL_COLOR, 0, clearColor);
  32.             glClear(GL_DEPTH_BUFFER_BIT);
  34.             glm::mat4 I(1.0f);
  35.             glm::vec3 X(1.0f, 0.0f, 0.0f);
  36.             glm::vec3 Y(0.0f, 1.0f, 0.0f);
  37.             glm::vec3 Z(0.0f, 0.0f, 1.0f);
  39.             glm::mat4 view_matrix = glm::lookAt(cameraPosition, cameraPosition + cameraFront, cameraUp);
  41.             glm::mat4 projection_matrix = glm::perspective(glm::radians(45.0f), aspect, 1.0f, 100.0f);
  43.             glm::mat4 allis_model_matrix = glm::translate(I, glm::vec3(0.0f, 2.0f, 0.0f)) 
  44.                                             * glm::scale(I, glm::vec3(0.8f, 0.8f, 0.8f)) * glm::rotate(I, glm::radians(0.0f), X);
  45.             
  46.             simpleShader->setModelMatrix(allis_model_matrix);
  47.             simpleShader->setViewMatrix(view_matrix);
  48.             simpleShader->setProjectionMatrix(projection_matrix);
  49.             simpleShader->setCurrent();
  50.             lita.render();
  52.         }
  54.         ~MyApp(){
  55.             if(simpleShader != NULL){
  56.                 delete simpleShader;
  57.             }
  58.         }
  60. };
  63. DECLARE_MAIN(MyApp)

编译运行的命令如下：

  1. g++ -o WanderInScene WanderInScene.cpp -lGL -lglfw -lGLEW -lassimp
  2. ./WanderInScene

就可以看到程序运行的效果了，我们可以很方便地从不同角度、不同距离观察 3D 模型，如下图：

该随笔由京山游侠在2021年08月09日发布于博客园，引用请注明出处，转载或出版请联系博主。QQ邮箱：1841079@qq.com

版权声明：本文为youxia原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/youxia/p/cg006.html