OpenGL入门2：第一个窗口

一时失言乱红尘 2021-11-29 13:14 353阅读 0赞

**本文是个人学习记录，非原创，学习建议看教程** [https://learnopengl-cn.github.io/][https_learnopengl-cn.github.io]  
非常感谢原作者JoeyDeVries和多为中文翻译者提供的优质教程

## 测试GLFW ##

在我们的test.cpp中加入下面两个头文件

#include <glad/glad.h>
    #include <GLFW/glfw3.h>

接下来我们在main函数里写上如下代码，在main里我们将会实例化GLFW窗口：

int main()
    {
        glfwInit();
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);//for Mac
    
        return 0;
    }

首先，调用**glfwInit()**函数来初始化GLFW，然后使用**glfwWindowHint()**函数来配置GLFW

**glfwWindowHint()**函数的第一个参数代表选项的名称，我们可以从很多以**GLFW\_**开头的枚举值中选择；第二个参数接受一个整型，用来设置这个选项的值  
该函数的所有的选项以及对应的值都可以在 [GLFW’s window handling][GLFW_s window handling] 这篇文档中找到  
如果你现在编译你的cpp文件会得到大量的 ***undefined reference*** (未定义的引用) 错误，也就是说你并未顺利地链接GLFW库

由于我看的教程是基于OpenGL 3.3版本展开讨论的，所以我们需要告诉GLFW我们要使用的OpenGL版本是3.3，所以我们将主版本号(Major)和次版本号(Minor)都设为3，这样GLFW会在创建OpenGL上下文时做出适当的调整，这也可以确保用户在没有适当的OpenGL版本支持的情况下无法运行

我们同样明确告诉GLFW我们使用的是核心模式(**Core-profile**)。明确告诉GLFW我们需要使用核心模式意味着我们只能使用OpenGL功能的一个子集（没有我们已不再需要的向后兼容特性）

如果使用的是Mac OS X系统，还需要将上面的代码解除注释

--------------------

接下来我们创建一个窗口对象，这个窗口对象存放了所有和窗口相关的数据，而且会被GLFW的其他函数频繁地用到

GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

**glfwCreateWindow()**函数需要窗口的**宽**和**高**作为它的前两个参数，第三个参数表示这个**窗口的名称**(标题)，这里我使用**"LearnOpenGL"**，当然你也可以使用你喜欢的名称，最后两个参数我们暂时忽略

这个函数将会返回一个GLFWwindow对象，我们会在其它的GLFW操作中使用到，创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了

## GLAD ##

GLAD是用来管理OpenGL的函数指针的，所以在调用任何OpenGL的函数之前我们需要初始化GLAD

if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

我们给GLAD传入了用来加载系统相关的OpenGL函数指针地址的函数。GLFW给我们的是**glfwGetProcAddress**，它根据我们编译的系统定义了正确的函数。

## 视口 ##

在我们开始渲染之前，我们必须告诉OpenGL渲染窗口的尺寸大小，即视口(Viewport)，这样OpenGL才只能知道怎样根据窗口大小显示数据和坐标。我们可以通过调用glViewport函数来设置窗口的**维度**(Dimension)：

glViewport(0, 0, 800, 600);

glViewport函数前两个参数控制**窗口左下角的位置**，第三个和第四个参数控制渲染窗口的**宽度和高度**（像素）

我们实际上也可以将视口的维度设置为比GLFW的维度小，这样子之后所有的OpenGL渲染将会在一个更小的窗口中显示，这样子的话我们也可以将一些其它元素显示在OpenGL视口之外

> OpenGL幕后使用glViewport中定义的位置和宽高进行2D坐标的转换，将OpenGL中的位置坐标转换为你的屏幕坐标。例如，OpenGL中的坐标(-0.5, 0.5)有可能（最终）被映射为屏幕中的坐标(200,450)。注意，处理过的OpenGL坐标范围只为-1到1，因此我们事实上将(-1到1)范围内的坐标映射到(0, 800)和(0, 600)。

然而，当用户改变窗口的大小的时候，视口也应该被调整。我们可以对窗口注册一个**回调函数(Callback Function)**，它会在每次窗口大小被调整的时候被调用。这个回调函数的原型如下：

void framebuffer_size_callback(GLFWwindow* window, int width, int height);

这个帧缓冲大小函数需要一个GLFWwindow作为它的第一个参数，以及两个整数表示窗口的新维度。每当窗口改变大小，GLFW会调用这个函数并填充相应的参数供你处理

void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    {
        glViewport(0, 0, width, height);
    }

我们还需要注册这个函数，告诉GLFW我们希望每当窗口调整大小的时候调用这个函数：

glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

当窗口被第一次显示的时候framebuffer\_size\_callback也会被调用，对于视网膜(Retina)显示屏，width和height都会明显比原输入值更高一点

我们还可以将我们的函数注册到其它很多的回调函数中，比如说，我们可以创建一个回调函数来处理手柄输入变化，处理错误消息等，我们会在创建窗口之后，渲染循环初始化之前注册这些回调函数

## 渲染循环 ##

我们不希望只绘制一个图像之后我们的应用程序就立即退出并关闭窗口，而是希望程序在我们主动关闭它之前不断绘制图像并能够接受用户输入，因此，我们需要在程序中添加一个while循环，我们可以把它称之为**渲染循环(Render Loop)**，它能在我们让GLFW退出前一直保持运行，下面几行的代码就实现了一个简单的渲染循环：

while(!glfwWindowShouldClose(window))
    {
        glfwSwapBuffers(window);
        glfwPollEvents();    
    }

*  glfwWindowShouldClose函数在我们每次循环的开始前检查一次GLFW是否被要求退出，如果是的话该函数返回 true 然后渲染循环便结束了，之后为我们就可以关闭应用程序了
 *  glfwPollEvents函数检查有没有触发什么事件（比如键盘输入、鼠标移动等）、更新窗口状态，并调用对应的回调函数（可以通过回调方法手动设置）
 *  glfwSwapBuffers函数会交换颜色缓冲（它是一个储存着GLFW窗口每一个像素颜色值的大缓冲），它在这一迭代中被用来绘制，并且将会作为输出显示在屏幕上

> **双缓冲(Double Buffer)**
> 
> 应用程序使用单缓冲绘图时可能会存在图像闪烁的问题。 这是因为生成的图像不是一下子被绘制出来的，而是按照从左到右，由上而下逐像素地绘制而成的。最终图像不是在瞬间显示给用户，而是通过一步一步生成的，这会导致渲染的结果很不真实。为了规避这些问题，我们应用双缓冲渲染窗口应用程序。**前**缓冲保存着最终输出的图像，它会在屏幕上显示；而所有的的渲染指令都会在**后**缓冲上绘制。当所有的渲染指令执行完毕后，我们**交换**(Swap)前缓冲和后缓冲，这样图像就立即呈显出来，之前提到的不真实感就消除了。

## 最后一件事 ##

当渲染循环结束后我们需要正确**释放/删除之前的分配的所有资源**，我们可以在main函数的最后调用**glfwTerminate()**来完成。

glfwTerminate();
    return 0;

这样便能清理所有的资源并正确地退出应用程序

现在我们的代码是这样的

#include <glad/glad.h>
    #include <GLFW/glfw3.h>
    #include <iostream>
    
    void framebuffer_size_callback(GLFWwindow* window, int width, int height);
    
    int main()
    {
        glfwInit();
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    
        GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
        if (window == NULL)
        {
            std::cout << "Failed to create GLFW window" << std::endl;
            glfwTerminate();
            return -1;
        }
        glfwMakeContextCurrent(window);
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
        
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
        {
            std::cout << "Failed to initialize GLAD" << std::endl;
            return -1;
        }    
    
    
        while (!glfwWindowShouldClose(window))
        {
            glfwSwapBuffers(window);
            glfwPollEvents();
        }
    
        glfwTerminate();
        return 0;
    }
    
    void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    {
        glViewport(0, 0, width, height);
    }

现在你可以尝试编译并运行我们的应用程序了，如果没做错的话，你将会看到如下的输出：

![1536438-20190712101236714-1750766126.png][]

一个非常无聊的黑色窗口，这就对了！

--------------------

## 输入 ##

我们同样也希望能够在GLFW中实现一些输入控制，这可以通过使用GLFW的几个输入函数来完成。我们将会使用GLFW的glfwGetKey函数，它需要一个窗口以及一个按键作为输入，这个函数将会返回这个按键是否正在被按下，我们将创建一个**processInput**函数来让所有的输入代码保持整洁

void processInput(GLFWwindow *window)
    {
        if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//是否按下了返回键
            glfwSetWindowShouldClose(window, true);
    }

这里我们检查用户是否按下了返回键(Esc)（如果没有按下，glfwGetKey 将会返回 **GLFW\_RELEASE**，如果用户的确按下了返回键，我们将通过 glfwSetwindowShouldClose 使用把 WindowShouldClose 属性设置为 true 的方法关闭GLFW，下一次while循环的条件检测将会失败，程序将会关闭

我们接下来在渲染循环的每一个迭代中加入 processInput 的调用：

while (!glfwWindowShouldClose(window))
    {
        processInput(window);
    
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

这就给我们一个非常简单的方式来检测特定的键是否被按下，并在每一帧做出处理

## 渲染 ##

我们要把所有的渲染(Rendering)操作放到渲染循环中，因为我们想让这些渲染指令在每次渲染循环迭代的时候都能被执行，代码将会是这样的：

![1536438-20190712104032288-385718372.png][]

为了测试一切都正常工作，我们使用一个自定义的颜色清空屏幕

在每个新的渲染迭代开始的时候我们总是希望清屏，否则我们仍能看见上一次迭代的渲染结果（这可能是你想要的效果，但通常这不是）

我们可以通过调用glClear函数来清空屏幕的颜色缓冲，它接受一个缓冲位(Buffer Bit)来指定要清空的缓冲，可能的缓冲位有 GL\_COLOR\_BUFFER\_BIT，GL\_DEPTH\_BUFFER\_BIT 和 GL\_STENCIL\_BUFFER\_BIT

由于现在我们只关心颜色值，所以我们只清空**颜色缓冲 GL\_COLOR\_BUFFER\_BIT**，讲下述代码加入到渲染循环的渲染指令部分

glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

注意，除了glClear之外，我们还调用了**glClearColor来设置清空屏幕所用的颜色**，当调用glClear函数，清除颜色缓冲之后，整个颜色缓冲都会被填充为glClearColor里所设置的颜色

现在我的代码是这样的：

#include <glad/glad.h>
    #include <GLFW/glfw3.h>
    #include <iostream>
    
    void framebuffer_size_callback(GLFWwindow* window, int width, int height);
    void processInput(GLFWwindow *window);
    
    int main()
    {
        glfwInit();
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    
        GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
        if (window == NULL)
        {
            std::cout << "Failed to create GLFW window" << std::endl;
            glfwTerminate();
            return -1;
        }
        glfwMakeContextCurrent(window);
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
        {
            std::cout << "Failed to initialize GLAD" << std::endl;
            return -1;
        }
    
    
        // 渲染循环
        while (!glfwWindowShouldClose(window))
        {
            // 输入
            processInput(window);
    
            // 渲染指令
            glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);
    
            // 检查并调用事件，交换缓冲
            glfwSwapBuffers(window);
            glfwPollEvents();
        }
    
        glfwTerminate();
        return 0;
    }
    
    void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    {
        glViewport(0, 0, width, height);
    }
    
    void processInput(GLFWwindow *window)
    {
        if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//是否按下了返回键
            glfwSetWindowShouldClose(window, true);
    }

编译运行：

![1536438-20190712154450889-1923737308.png][]

我们将屏幕设置为了类似黑板的深蓝绿色，并且按Esc才会结束运行

> glClearColor函数是一个**状态设置**函数，而glClear函数则是一个**状态使用**的函数，它使用了当前的状态来获取应该清除为的颜色。

至此，现在我们已经做好开始在渲染循环中添加许多渲染调用的准备了

参考源代码：

#include <glad/glad.h>
    #include <GLFW/glfw3.h>
    
    #include <iostream>
    
    void framebuffer_size_callback(GLFWwindow* window, int width, int height);
    void processInput(GLFWwindow *window);
    
    // settings
    const unsigned int SCR_WIDTH = 800;
    const unsigned int SCR_HEIGHT = 600;
    
    int main()
    {
        // glfw: initialize and configure
        // ------------------------------
        glfwInit();
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    
    #ifdef __APPLE__
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
    #endif
    
        // glfw window creation
        // --------------------
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
        if (window == NULL)
        {
            std::cout << "Failed to create GLFW window" << std::endl;
            glfwTerminate();
            return -1;
        }
        glfwMakeContextCurrent(window);
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    
        // glad: load all OpenGL function pointers
        // ---------------------------------------
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
        {
            std::cout << "Failed to initialize GLAD" << std::endl;
            return -1;
        }    
    
        // render loop
        // -----------
        while (!glfwWindowShouldClose(window))
        {
            // input
            // -----
            processInput(window);
    
            // render
            // ------
            glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);
    
            // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
            // -------------------------------------------------------------------------------
            glfwSwapBuffers(window);
            glfwPollEvents();
        }
    
        // glfw: terminate, clearing all previously allocated GLFW resources.
        // ------------------------------------------------------------------
        glfwTerminate();
        return 0;
    }
    
    // process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
    // ---------------------------------------------------------------------------------------------------------
    void processInput(GLFWwindow *window)
    {
        if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
            glfwSetWindowShouldClose(window, true);
    }
    
    // glfw: whenever the window size changed (by OS or user resize) this callback function executes
    // ---------------------------------------------------------------------------------------------
    void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    {
        // make sure the viewport matches the new window dimensions; note that width and 
        // height will be significantly larger than specified on retina displays.
        glViewport(0, 0, width, height);
    }

转载于:https://www.cnblogs.com/zhxmdefj/p/11174728.html

[https_learnopengl-cn.github.io]: https://learnopengl-cn.github.io/
[GLFW_s window handling]: http://www.glfw.org/docs/latest/window.html#window_hints
[1536438-20190712101236714-1750766126.png]: /images/20211129/289d5326bc78477ebcba99bbf9015c47.png
[1536438-20190712104032288-385718372.png]: /images/20211129/cde49cd4a6314e7da52deb98aa008f46.png
[1536438-20190712154450889-1923737308.png]: /images/20211129/402a66a02f7e435b9c8aa16703beaa27.png