OpenGL的窗口创建

原创于 2025-03-08 14:11:38 发布 · 1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #开发语言

计算机图形学专栏收录该内容

3 篇文章

订阅专栏

程序流程

函数声明，有先后顺序，要不然会报错

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

初始化

代码片段

glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

初始化OpenGL和GLFW库

glfwInit();

设置OpenGL的版本信息，4.6版本

GLFW_CONTEXT_VERSION_MAJOR 表示主要版本号

GLFW_CONTEXT_VERSION_MINOR 表示次要版本号

glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);

设置OpenGL的渲染模式

GLFW_OPENGL_PROFILE 表示OpenGL的渲染模式profile
GLFW_OPENGL_CORE_PROFILE 表示使用核心版本（Core Profile）
这将限制OpenGL的高级功能，保持应用程序的低资源占用

 glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

关于forward compatibility的设置

这一行通常需要根据项目需求来决定是否启用forward compatibility
如果需要，可以将注释去掉并设置为GL_TRUE
如果不需要，可以保留注释以提醒自己可能需要调整

glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

创建窗口

创建一个窗口对象window,这个窗口对象存放了所有和窗口相关的数据，而且会被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);

加载opengl所需要的核心函数

GLAD是用来管理OpenGL的函数指针的，所以在调用任何OpenGL的函数之前我们需要初始化GLAD。
gladLoadGLLoader是GLAD用来加载OpenGL函数的核心函数。
glfwGetProcAddress是GLFW提供的函数，用于获取OpenGL函数的地址。
通过将glfwGetProcAddress强制转换为GLADloadproc类型，
将其传递给gladLoadGLLoader，从而完成OpenGL函数的加载。

就是把opengl函数的地址（glfwGetProcAddress）强转成GLADloadproc放到gladLoadGLLoader里面

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

创建视口

视口的初始化

在我们开始渲染之前还有一件重要的事情要做，我们必须告诉OpenGL渲染窗口的尺寸大小，即视口(Viewport)，
这样OpenGL才只能知道怎样根据窗口大小显示数据和坐标。
我们可以通过调用glViewport函数来设置视口的尺寸(Dimension)：
视口
glViewport函数前两个参数控制窗口左下角的位置。
第三个和第四个参数控制渲染窗口的宽度和高度（像素）。

glViewport(0, 0, 800, 600);

视口的动态调整函数

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

函数主体

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

把framebuffer_size_callback函数里面 glViewport函数得到的窗口数据，放到之前定义的存放窗口相关数据的*window数组中

函数调用

 glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

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

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

函数的声明

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

引擎---渲染循环(Render Loop)

代码片段

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

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

双缓冲(Double Buffer)

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

资源释放

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

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

glfwTerminate();
return 0;

其他功能优化

输入交互

ESC退出交互

WindowShouldClose属性设置为 true来关闭GLFW

调用

 processInput(window);

函数主体

void processInput(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

位置：放在while循环中判断

   while (!glfwWindowShouldClose(window))
   {
       processInput(window);

       glfwSwapBuffers(window);
       glfwPollEvents();
   }

设置屏幕颜色（渲染(Rendering)）

为了测试一切都正常工作，我们使用一个自定义的颜色清空屏幕。在每个新的渲染迭代开始的时候我们总是希望清屏，否则我们仍能看见上一次迭代的渲染结果（这可能是你想要的效果，但通常这不是）。

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

除了glClear之外，我们还调用了glClearColor来设置清空屏幕所用的颜色。当调用glClear函数，清除颜色缓冲之后，整个颜色缓冲都会被填充为glClearColor里所设置的颜色。在这里，我们将屏幕设置为了类似黑板的深蓝绿色。

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

位置

// 渲染循环
while(!glfwWindowShouldClose(window))
{
    // 输入
    processInput(window);

    // 渲染指令
    ...

    // 检查并调用事件，交换缓冲
    glfwPollEvents();
    glfwSwapBuffers(window);
}

全部代码

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

#include<iostream>

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

const unsigned int VIEW_WIDTH = 800;
const unsigned int VIEW_HEIGHT = 600;

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

int main()
{
    int glfwSate = glfwInit();
    if (glfwSate == GLFW_FALSE)
    {
        std::cout << "GLFW initialize failed!" << std::endl;
        exit(EXIT_FAILURE);
    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

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

    // glad: load all OpenGL function pointers
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    //glfwSetKeyCallback
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    while (!glfwWindowShouldClose(window))
    {
        glClear(GL_COLOR_BUFFER_BIT);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glfwTerminate();
    return 0;
}

void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    std::cout << "Call frame buffer callback function!" << std::endl;
    glViewport(0, 0, width, height);
}*/

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

// 视口调整回调函数
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

// 键盘输入回调函数
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, true);
    }

    // 按下W键时输出调试信息（可选）
    if (key == GLFW_KEY_W && action == GLFW_PRESS) {
        std::cout << "W key pressed!" << std::endl;
    }

}

int main() {
    // 初始化GLFW
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // 创建窗口
    GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Window", NULL, NULL);
    if (window == NULL) {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

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

    // 设置视口和回调
    glViewport(0, 0, 800, 600);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetKeyCallback(window, key_callback);

    // 渲染循环
    while (!glfwWindowShouldClose(window)) {
        // 清屏
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);






        // 交换缓冲并处理事件
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 清理资源
    glfwTerminate();
    return 0;
}

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

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow* window);
// 这是一个简单的OpenGL图形应用程序的主函数。

int main() {
    // 初始化OpenGL和GLFW库
    glfwInit();

    // 设置OpenGL的版本信息
    // GLFW_CONTEXT_VERSION_MAJOR 表示主要版本号
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);

    // 设置OpenGL的次要版本号
    // GLFW_CONTEXT_VERSION_MINOR 表示次要版本号
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);

    // 设置OpenGL的渲染模式
    // GLFW_OPENGL_PROFILE 表示OpenGL的渲染模式profile
    // GLFW_OPENGL_CORE_PROFILE 表示使用核心版本（Core Profile）
    // 这将限制OpenGL的高级功能，保持应用程序的低资源占用
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // 以下注释行是关于forward compatibility的设置

    // 这一行通常需要根据项目需求来决定是否启用forward compatibility
    // 如果需要，可以将注释去掉并设置为GL_TRUE
    // 如果不需要，可以保留注释以提醒自己可能需要调整
    //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    //创建一个窗口对象window,这个窗口对象存放了所有和窗口相关的数据，而且会被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);

   //GLAD是用来管理OpenGL的函数指针的，所以在调用任何OpenGL的函数之前我们需要初始化GLAD
   //gladLoadGLLoader是GLAD用来加载OpenGL函数的核心函数。
   //glfwGetProcAddress是GLFW提供的函数，用于获取OpenGL函数的地址。
   //通过将glfwGetProcAddress强制转换为GLADloadproc类型，
   // 将其传递给gladLoadGLLoader，从而完成OpenGL函数的加载。
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    //在我们开始渲染之前还有一件重要的事情要做，我们必须告诉OpenGL渲染窗口的尺寸大小，即视口(Viewport)，
    // 这样OpenGL才只能知道怎样根据窗口大小显示数据和坐标。
    // 我们可以通过调用glViewport函数来设置视口的尺寸(Dimension)：
    //视口
    //glViewport函数前两个参数控制窗口左下角的位置。
    // 第三个和第四个参数控制渲染窗口的宽度和高度（像素）。
    glViewport(0, 0, 800, 600);
    //我们实际上也可以将视口的维度设置为比GLFW的维度小，
    // 这样子之后所有的OpenGL渲染将会在一个更小的窗口中显示，
    // 这样子的话我们也可以将一些其它元素显示在OpenGL视口之外。

    //视口被调整的函数调用
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
   
    //渲染循环(Render Loop)
    //让GLFW退出前一直保持运行
    //
    //glfwWindowShouldClose函数在我们每次循环的开始前检查一次GLFW是否被要求退出，如果是的话，该函数返回true，渲染循环将停止运行，之后我们就可以关闭应用程序。
    //glfwPollEvents函数检查有没有触发什么事件（比如键盘输入、鼠标移动等）、更新窗口状态，并调用对应的回调函数（可以通过回调方法手动设置）。
    //glfwSwapBuffers函数会交换颜色缓冲（它是一个储存着GLFW窗口每一个像素颜色值的大缓冲），它在这一迭代中被用来绘制，并且将会作为输出显示在屏幕上。
    while (!glfwWindowShouldClose(window))
    {
        //输入交互指令
        processInput(window);
        //渲染指令
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    
    glfwTerminate();

    // 返回0表示程序正常结束
    return 0;
}


//当用户改变窗口的大小的时候，视口也应该被调整。
// 我们可以对窗口注册一个回调函数(Callback Function)，
// 它会在每次窗口大小被调整的时候被调用
// 
//这个帧缓冲大小函数需要一个GLFWwindow作为它的第一个参数，
// 以及两个整数表示窗口的新维度。
// 每当窗口改变大小，GLFW会调用这个函数并填充相应的参数供你处理。
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);
}

#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);
#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);
}