OpenGL 入门（六）— Coordinate Systems（坐标系统或坐标空间）

最新推荐文章于 2024-04-30 14:25:11 发布
最新推荐文章于 2024-04-30 14:25:11 发布
阅读量1k 收藏 14
点赞数 28
分类专栏： OpenGL 开发之路 文章标签： c++ OpenGL vscode 着色器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40120946/article/details/135988224
版权

文章目录

前言

坐标转换

为了将坐标从一个坐标系变换到另一个坐标系，我们需要用到几个变换矩阵，最重要的几个分别是模型(Model)、观察(View)、投影(Projection)三个矩阵。

下面一个Cube从模型坐标本投射到屏幕坐标上完整流程展示：
请添加图片描述
顶点位置和法向量等几何数据在OpenGL流水线中通过顶点操作和原始装配操作进行转换，然后再进行网格化处理。
在这里插入图片描述
渲染流水线中顶点的空间变换过程：

在这里插入图片描述

局部空间

局部空间(Local Space，或者称为物体空间(Object Space))，是指物体所在的坐标空间，即对象最开始所在的地方。

你的模型的所有顶点都是在局部空间中：它们相对于你的物体来说都是局部的。

世界空间

世界空间(World Space)：是指顶点相对于（游戏）世界的坐标。通常，我们会把世界空间的原点放置在游戏空间的中心。

顶点变换的第一步

如果将顶点坐标从模型空间变换到世界空间中，需要通过模型变换 (model transform)、模型矩阵(Model Matrix)来实现。

具体做法：

  • 先将物体的本地坐标系转成世界坐标系中，用变换矩阵表示；
  • 然后，物体本地坐标*变换矩阵=物体世界坐标；

这里有个B站视频方便理解：【CTO教程系列】计算机图形管线 3.模型变换

blog.csdnimg.cn/direct/c28680e1c43744d79a0e55ba1fa76481.png)

观察空间

观察空间经常被人们称之OpenGL的摄像机(Camera)（所以有时也称为摄像机空间(Camera Space)或视觉空间(Eye Space)）。

观察空间是将世界空间坐标转化为用户视野前方的坐标而产生的结果。因此观察空间就是从摄像机的视角所观察到的空间。

观察空间和屏幕空间区别：观察空间是一个三维空间 ，而屏幕空是一个二维空间。从观察空间到屏幕空间的转换需要经过一个操作， 那就投影 (projection) 。

顶点变换的第二步

是将顶点坐标从世界空间变换到观察空间中，这个变换通常叫做观察变换 (view transform)。

这些组合在一起的变换通常存储在一个观察矩阵(View Matrix)里，它被用来将世界坐标变换到观察空间。

在这里插入图片描述
在这里插入图片描述

这里有个B站视频方便理解：【CTO教程系列】计算机图形管线 4.ModelView变换

需要注意的是在OpenGL观察空间使用的是右手坐标系，因此需要在z轴值取反操作。

裁剪空间

裁剪空间(Clip Space)

在一个顶点着色器运行的最后，OpenGL所有的坐标都能落在一个特定的范围内，且任何在这个范围之外的点都应该被裁剪掉(Clipped)。

被裁剪掉的坐标就会被忽略，所以剩下的坐标就将变为屏幕上可见的片段。

可以使用投影矩阵(Projection Matrix)将顶点坐标从观察变换到裁剪空间。
投影矩阵可以为两种不同的形式：

正交投影

正交投影定义了一个类似立方体的平截头箱，它定义了一个裁剪空间，在这空间之外的顶点都会被裁剪掉。平行投影，没有远近距离关系。

它的平截头体看起来像一个容器：
请添加图片描述

正交投影矩阵(Orthographic Projection Matrix)

要创建一个正交投影矩阵，我们可以使用GLM的内置函数glm::ortho：

glm::ortho(0.0f, 800.0f, 0.0f, 600.0f, 0.1f, 100.0f);

正交投影矩阵直接将坐标映射到2D屏幕上，但会产生不真实的结果。

很多地方也会用的到，比如游戏中王者、LOL的小地图，2D游戏等等。

这里有个B站视频方便理解：

【CTO教程系列】计算机图形管线 7.正交投影变换

【CTO教程系列】计算机图形管线 8.正交投影变换（续）

【CTO教程系列】计算机图形管线 9.正交投影 in OpenGL

透视投影

请添加图片描述

透视投影是一种更贴近实际生活的投影，由于透视，这两条线在很远的地方看起来会相交。这正是透视投影想要模仿的效果，它是使用透视投影矩阵(Perspective Projection Matrix)来完成的。

这个投影矩阵将给定的平截头体范围映射到裁剪空间，除此之外还修改了每个顶点坐标的w值，从而使得离观察者越远的顶点坐标w分量越大。被变换到裁剪空间的坐标都会在-w到w的范围之间（任何大于这个范围的坐标都会被裁剪掉）。

OpenGL要求所有可见的坐标都落在-1.0到1.0范围内，作为顶点着色器最后的输出，因此，一旦坐标在裁剪空间内之后，透视除法就会被应用到裁剪空间坐标上：

o u t = ( x / w y / w z / w ) out= \begin{pmatrix} x/w \\ y/w \\ z/w \end{pmatrix} out= ​x/wy/wz/w​ ​

顶点坐标的每个分量都会除以它的w分量，距离观察者越远顶点坐标就会越小。

在GLM中可以这样创建一个透视投影矩阵：

glm::mat4 proj = glm::perspective(glm::radians(45.0f), (float)width/(float)height, 0.1f, 100.0f);

同样，glm::perspective所做的其实就是创建了一个定义了可视空间的大平截头体，任何在这个平截头体以外的东西最后都不会出现在裁剪空间体积内，并且将会受到裁剪。

请添加图片描述
侧切面：

在这里插入图片描述

这里有个B站视频方便理解：

【CTO教程系列】计算机图形管线 10.透视投影变换】

【CTO教程系列】计算机图形管线 11.透视投影变换（续）

【CTO教程系列】计算机图形管线 12.透视投影 in OpenGL

屏幕空间

屏幕空间(Screen Space)

由投影矩阵创建的观察箱(Viewing Box)被称为平截头体(Frustum)，每个出现在平截头体范围内的坐标都会最终出现在用户的屏幕上

OpenGL然后对裁剪坐标执行透视除法从而将它们变换到标准化设备坐标。

总结

上述的每一个步骤都创建了一个变换矩阵：模型矩阵、观察矩阵和投影矩阵。一个顶点坐标将会根据以下过程被变换到裁剪坐标：

V c l i p = M p r o j e c t i o n ⋅ M v i e w ⋅ M m o d e l ⋅ V l o c a l V_{clip}=M_{projection}⋅M_{view}⋅M_{model}⋅V_{local} Vclip​=Mprojection​⋅Mview​⋅Mmodel​⋅Vlocal​

注意矩阵运算的顺序是相反的（记住我们需要从右往左阅读矩阵的乘法）。最后的顶点应该被赋值到顶点着色器中的gl_Position，OpenGL将会自动进行透视除法和裁剪。

OpenGL然后对裁剪坐标执行透视除法从而将它们变换到标准化设备坐标。

OpenGL会使用glViewPort内部的参数来将标准化设备坐标映射到屏幕坐标，每个坐标都关联了一个屏幕上的点。这个过程称为视口变换。

这里有个B站视频方便理解：

【CTO教程系列】计算机图形管线 13.视口变换】

【CTO教程系列】计算机图形管线 14.视口变换 in OpenGL】

扩展实践：3D绘图

深度缓冲(Depth Buffer)

OpenGL存储它的所有深度信息于一个Z缓冲(Z-buffer)中，也被称为深度缓冲(Depth Buffer)。

深度值存储在每个片段里面（作为片段的z值），当片段想要输出它的颜色时，OpenGL会将它的深度值和z缓冲进行比较，如果当前的片段在其它片段之后，它将会被丢弃，否则将会覆盖。这个过程称为深度测试(Depth Testing)，它是由OpenGL自动完成的。

现在我们想启用深度测试，需要开启GL_DEPTH_TEST：

glEnable(GL_DEPTH_TEST);

因为我们使用了深度测试，我们也想要在每次渲染迭代之前清除深度缓冲（否则前一帧的深度信息仍然保存在缓冲中）:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

实践

  1. 启用深度测试：glEnable(GL_DEPTH_TEST);

  2. 构建和编译着色程序：
    在这里插入图片描述

    • 顶点着色器
    #version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord;

out vec2 TexCoord;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
gl_Position = projection * view * model * vec4(aPos, 1.0f);
TexCoord = vec2(aTexCoord.x, 1.0 - aTexCoord.y);
}
    • 片元着色器
    #version 330 core
out vec4 FragColor;

in vec2 TexCoord;

uniform sampler2D texture1;
uniform sampler2D texture2;

void main()
{
 FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2);
}
	```

  3. 设置顶点数据(和缓冲区)并配置顶点属性
    要想渲染一个立方体，我们一共需要36个顶点：

    // 1.设置立方体顶点输入  一共需要36个顶点
float vertices[] = {...};
// 立方体的世界空间位置
glm::vec3 cubePositions[] = {...};

  4. 清除深度缓冲，创建变换、观察矩阵，投影矩阵

    	...
    // 渲染
    // 清除颜色缓冲
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    // 清除深度缓冲
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // 在相应的纹理单元上绑定纹理
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture1);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, texture2);
	...

  5. 创建变换、观察矩阵，投影矩阵

    • 正交投影
    	...
   ourShader.use();

   // 创建变换、观察矩阵，投影矩阵
   glm::mat4 view = glm::mat4(1.0f); // 模型矩阵
   view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));

   // 正交投影
   glm::mat4 ortho = glm::mat4(1.0f);
   ortho = glm::ortho(-width / 200.0f, width / 200.0f, -height / 200.0f, height / 200.0f, 0.1f, 100.0f); // 正交投影
   ourShader.setMat4("projection", ortho);

   // 观察矩阵
   ourShader.setMat4("view", view);
   ...
    • 透视投影
    	...
   ourShader.use();

   // 创建变换、观察矩阵，投影矩阵
   glm::mat4 view = glm::mat4(1.0f); // 模型矩阵
   view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));

   // 透视投影
   glm::mat4 projection = glm::mat4(1.0f);                                                                 // 投影矩阵
   projection = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); // 透视投影
   // 将矩阵传递给着色器
   ourShader.setMat4("projection", projection);

   // 观察矩阵
   ourShader.setMat4("view", view);
    ···

  6. 绘制立方体

    	...
	// 绘制三角形
    glBindVertexArray(VAO); // 绑定VAO

    for (unsigned int i = 0; i < 10; i++)
    {
        glm::mat4 model = glm::mat4(1.0f); // 模型矩阵
        model = glm::translate(model, cubePositions[i]);
        float angle = 20.0f * i;
        angle = (float)glfwGetTime() * 25.0f;
        model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));

        ourShader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36); // 绘制立方体
    }
    ...

完整源码

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

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>

#include <shader_s.h>

void InitGLFW();
bool CreateWindow();
bool InitGLAD();
// 窗口大小改变时调用
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;

GLFWwindow *window;

int main()
{
    InitGLFW(); // 初始化GLFW

    bool isCreated = CreateWindow(); // 创建一个窗口对象
    if (!isCreated)
        return -1;
    bool isGLAD = InitGLAD(); // 初始化GLAD，传入加载系统相关opengl函数指针的函数
    if (!isGLAD)
        return -1;

    // 启用深度测试
    glEnable(GL_DEPTH_TEST);

    // 构建和编译着色程序
    Shader ourShader("shader/P1_Basic/06_Coordinate/coordinate.vs", "shader/P1_Basic/06_Coordinate/coordinate.fs");

    // 设置顶点数据(和缓冲区)并配置顶点属性
    // 1.设置立方体顶点输入  一共需要36个顶点
    float vertices[] = {
        -0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
        0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        -0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f, 0.0f, 0.0f,

        -0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
        0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
        -0.5f, 0.5f, 0.5f, 0.0f, 1.0f,
        -0.5f, -0.5f, 0.5f, 0.0f, 0.0f,

        -0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
        -0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
        -0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
        -0.5f, 0.5f, 0.5f, 1.0f, 0.0f,

        0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
        0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
        0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
        0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
        0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
        0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
        -0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f, 0.0f, 1.0f,

        -0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
        0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
        -0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
        -0.5f, 0.5f, -0.5f, 0.0f, 1.0f};
    // world space positions of our cubes
    glm::vec3 cubePositions[] = {
        glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3(2.0f, 5.0f, -15.0f),
        glm::vec3(-1.5f, -2.2f, -2.5f),
        glm::vec3(-3.8f, -2.0f, -12.3f),
        glm::vec3(2.4f, -0.4f, -3.5f),
        glm::vec3(-1.7f, 3.0f, -7.5f),
        glm::vec3(1.3f, -2.0f, -2.5f),
        glm::vec3(1.5f, 2.0f, -2.5f),
        glm::vec3(1.5f, 0.2f, -1.5f),
        glm::vec3(-1.3f, 1.0f, -1.5f)};

    // 2.设置索引缓冲对象
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO); // 生成一个VAO对象
    glGenBuffers(1, &VBO);      // 生成一个VBO对象

    glBindVertexArray(VAO);
    // 绑定VAO
    glBindBuffer(GL_ARRAY_BUFFER, VBO);                                        // 绑定VBO
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // 将顶点数据复制到缓冲区中

    // 4.配置位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);
    // 5.   纹理属性
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);

    // 加载和创建纹理
    unsigned int texture1, texture2;
    // 加载第一张纹理图片
    glGenTextures(1, &texture1);            // 生成纹理
    glBindTexture(GL_TEXTURE_2D, texture1); // 绑定纹理
    // 设置纹理环绕方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // x轴
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // y轴
    // 设置纹理过滤方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 缩小
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 放大
    // 加载纹理图片,创建纹理和生成多级渐远纹理
    int width, height, nrChannels;
    stbi_set_flip_vertically_on_load(true); // stb_image.h能够在图像加载时帮助我们翻转y轴
    unsigned char *data = stbi_load("image/04_Textures/container.jpg", &width, &height, &nrChannels, 0);
    if (data)
    {
        // 生成纹理
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
        // 生成多级渐远纹理
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        std::cout << "Failed to load texture" << std::endl;
    }
    // 释放图像内存
    stbi_image_free(data);

    // 加载第二张纹理图片
    glGenTextures(1, &texture2);            // 生成纹理
    glBindTexture(GL_TEXTURE_2D, texture2); // 绑定纹理
    // 设置纹理环绕方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // x轴
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // y轴
    // 设置纹理过滤方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 缩小
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 放大
    // 加载纹理图片,创建纹理和生成多级渐远纹理
    data = stbi_load("image/04_Textures/awesomeface.png", &width, &height, &nrChannels, 0);
    if (data)
    {
        // 注意，awesomeface.png具有透明度，因此有一个alpha通道，所以一定要告诉OpenGL数据类型是GL_RGBA
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
        // 生成多级渐远纹理
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        std::cout << "Failed to load texture" << std::endl;
    }
    // 释放图像内存
    stbi_image_free(data);

    // 告诉opengl每个采样器属于哪个纹理单元(只需要做一次)
    ourShader.use();
    ourShader.setInt("texture1", 0);
    ourShader.setInt("texture2", 1);

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

        // 渲染
        // 清除颜色缓冲
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        // 清除深度缓冲
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // 在相应的纹理单元上绑定纹理
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture1);
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, texture2);

        ourShader.use();

        // 创建变换、观察矩阵，投影矩阵
        glm::mat4 view = glm::mat4(1.0f); // 模型矩阵
        view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));

        // 透视投影
        glm::mat4 projection = glm::mat4(1.0f);                                                                 // 投影矩阵
        projection = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); // 透视投影
        // 将矩阵传递给着色器
        ourShader.setMat4("projection", projection);

        // 正交投影
        // glm::mat4 ortho = glm::mat4(1.0f);
        // ortho = glm::ortho(-width / 200.0f, width / 200.0f, -height / 200.0f, height / 200.0f, 0.1f, 100.0f); // 正交投影
        // ourShader.setMat4("projection", ortho);

        // 观察矩阵
        ourShader.setMat4("view", view);

        // 绘制三角形
        glBindVertexArray(VAO); // 绑定VAO

        for (unsigned int i = 0; i < 10; i++)
        {
            glm::mat4 model = glm::mat4(1.0f); // 模型矩阵
            model = glm::translate(model, cubePositions[i]);
            float angle = 20.0f * i;
            angle = (float)glfwGetTime() * 25.0f;
            model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));

            ourShader.setMat4("model", model);
            glDrawArrays(GL_TRIANGLES, 0, 36); // 绘制立方体
        }

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

    // 可选:一旦资源超出其用途，就取消分配所有资源:
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);

    // 释放/删除之前的分配的所有资源
    glfwTerminate();
    return 0;
}

void InitGLFW()
{
    // 初始化GLFW
    glfwInit();
    // 配置GLFW  第一个参数代表选项的名称，我们可以从很多以GLFW_开头的枚举值中选择；
    // 第二个参数接受一个整型，用来设置这个选项的值。
    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);
}
bool CreateWindow()
{
    // 创建一个窗口对象
    window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        // 创建失败，终止程序
        glfwTerminate();
        return false;
    }
    // 将我们窗口的上下文设置为当前线程的主上下文
    glfwMakeContextCurrent(window);
    // 设置窗口大小改变时的回调函数
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    return true;
}
bool InitGLAD()
{
    // 初始化GLAD，传入加载系统相关opengl函数指针的函数
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        // 初始化失败，终止程序
        return false;
    }
    return true;
}

// 窗口大小改变时调用
void framebuffer_size_callback(GLFWwindow *window, int width, int height)
{
    // 设置窗口的维度
    glViewport(0, 0, width, height);
}

// 输入
void processInput(GLFWwindow *window)
{
    // 当用户按下esc键，我们设置window窗口的windowShouldClose属性为true
    // 关闭应用程序
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

效果图

正交投影
请添加图片描述
透视投影

请添加图片描述

iukam
关注
  • 28
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
「图形学/渲染管线/图元装配」透视投影矩阵的推导和原理解释
Arkish的博客
02-19 1353
透视投影矩阵的推导和原理解释，希望能帮助到你！
ARCGIS坐标系统问题.docx
11-18
在ARCgis中，地理坐标系统是指以WGS84或其他其他坐标系统为基准的坐标系统。 二、投影坐标系统（Projected Coordinate Systems） 投影坐标系统是指将地理坐标系统投影到二维平面上的坐标系统。如图2所示，投影坐标...
OpenGL 中的坐标变换
C_singleboy的专栏
08-13 885
1 OpenGL中的变换 变换(Transform)，可以使3D空间中的物体投影到2D平面上。使用变换，你可以移动、旋转、缩放甚至弯曲一个物体。然而变换并没有直接修改顶点 数据，取而代之，变换修改 1  OpenGL中的变换     变换(Transform)，可以使3D空间中的物体投影到2D平面上。使用变换，你可以移动、旋转、缩放甚至弯曲一个物体。然而变换并没有直接修改顶点
LearnOpenGL（六）之坐标系统
最新发布
ckg3824278的博客
04-30 1017
LearnOpenGL（六）之坐标系统
OpenGL坐标系转换
hhhhhhenrik的博客
11-04 2746
opengl笔记
OpenGL入门教程
少年的博客
04-26 485
到这里OpenGL入门教程就完结了。
OpenGL程序设计轻松入门
ark1111的专栏
09-26 2882
geographic_coordinate_systems_wkid_arcgis空间坐标编号_
09-30
arcgis空间坐标系编号，在请求地图的时候传入wkid号
zuobiaoxi.rar_polar coordinate_极坐标_极坐标 java
09-22
将笛卡尔坐标系上的点定义为一个服务类Point，Point类提供求得坐标系上两点间距离的功能、获取和设置坐标的功能、获取极坐标的功能，和完成对已创建的Point类对象统计功能。设计测试Point服务类的应用程序主类，测试...
zuobiaozhuanhuan.rar_arcgis coordinate_arcgis 坐标转换_坐标转换
09-14
arcgis线坐标转换,主要是将线坐标的坐标系统之间的转换
空间数据坐标转换基础整理
04-26
它可以分为两大类：Geographic Coordinate System（地理坐标系统）和Projection Coordinate System（投影坐标系统）。地理坐标系统是基于大地水准面和椭球体的数学曲面，它可以用来描述地球表面的几何模型。投影坐标...
OpenGL入门教程之 深入理解
少年的博客
04-19 1321
程序代码处于内存之中，在我们通常的理念中一般仅涉及CPU和内存，而使用OpenGL的渲染程序却有所不同，其。本文内容仅为个人在OpenGL学习中的感想，如有不当之处请不吝赐教。
OpenGl从零开始之坐标变换（上）
weixin_30273763的博客
12-02 294
　　坐标变换是深入理解三维世界的基础，非常重要。学习这部分首先要清楚几个概念：视点变换、模型变换、投影变换、视口变换。 　　在现实世界中，所有的物体都具有三维特征，但计算机本身只能处理数字，显示二维的图形，因此我们要将三维物体用二维数据表示出来，这一联系的点就是坐标。在OpenGL三维空间中坐标的形式有两种：世界坐标系和局部坐标系。 　　①世界坐标系：始终固定不变。举例，以太阳系中心太阳为中心...
OpenGL万字超详解笔记（适合新手小白）
particles的博客
03-19 1263
本文深入探讨了OpenGL图形API的基础知识，包括其跨平台特性和底层图形库的本质。文章重点介绍了OpenGL上下文的概念，它是OpenGL状态机的核心，保存着渲染状态和配置。通过实例，文章详细阐述了如何初始化OpenGL环境、配置视口、启用深度测试，以及如何创建和链接着色器程序。进一步，文章解释了VAO和VBO在OpenGL中的作用，并通过代码示例展示了如何设置和使用纹理。最后，文章讨论了不同的OpenGL绘制命令，包括glDrawArrays和glDrawElements，以及它们在实际渲染中的应用。整
【OpenGL】四、坐标系统和摄像机
qq_36674053的博客
10-20 261
LearnOpenGL个人心得总结
[OpenGL]OpenGL坐标系和坐标变换
whl0071的专栏
06-15 2702
OpenGL通过摄像机的模拟、要实现一个三维计算机图形重大转变，这是几何变换(模型转换—查看转型（两者统称为几何变换）)、投影、作物转型、口变换等。同一时候，OpenGL还实现了矩阵堆栈等。理解掌握了有关坐标变换的内容，就算真正走进了精彩地三维世界。OpenGL使用的是右手笛卡尔坐标系统，Z正轴垂直屏幕向外，X正轴从左到右。Y正轴从下到上。世界坐标系：在现实世界中，全部的物体都具有三维特征，但计算机本身仅仅能处理数字。显示二维的图形，将三维物体及二维数据联系在一起的唯一纽带就是坐标。为了使被显示的三维物体数
【openGL】安装篇(上)：Windows
热门推荐
Row Row Row your boat
01-11 1万+
环境 Windows7 x64 Visual Studio 2013 参考自 http://jingyan.baidu.com/article/d5c4b52bca5005da560dc5d6.html现在visual studio 都默认支持OpenGL，所以我们不需要再去官网下载OpenGL，但GLU是我们在学习过程中很有必要使用的.下载GLUThttp://www.opengl.org/res
【OpenGL】透视投影矩阵推导
weixin_44117236的博客
06-14 606
为什么缩放Z轴需要为负数？因为opengl把近平面和远平面，分别映射到-1和1。
opengl 绘制坐标系
06-07
在 OpenGL 中，可以通过绘制线段的方式来绘制坐标系。...注意，这段代码使用的是 OpenGL 2.x 的固定管线，如果要使用 OpenGL 3.x 或以上版本的着色器管线来绘制坐标系，需要使用着色器程序来实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值