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

最新推荐文章于 2024-09-17 13:36:55 发布
最新推荐文章于 2024-09-17 13:36:55 发布
阅读量1.2k 收藏 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
关注
专栏目录
OpenGL coordinate systems坐标系统的实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-25 284
OpenGL coordinate systems坐标系统先上图，再解答。完整主要的源代码源代码剖析 先上图，再解答。 完整主要的源代码 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <stb_image.h> #include <glm/glm.hpp> #include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/ty
现代opengl 设计入门，坐标系统和立方体的纹理贴图
曾立文的博客
02-03 1697
本文在 现代opengl 设计入门，纹理贴图 一文的基础上，引入opengl坐标系统，实现立方体的纹理贴图。介绍了opengl 的5个空间，3个变换矩阵。如果看这部分介绍比较繁琐，可以直接看看效果图，代码要点说明，利用提供的代码编译运行程序。 本文参照 https://learnopengl.com/  和 https://learnopengl-cn.github.io/ 学习而来，同时包含自...
OpenGL笔记十八之透视投影矩阵实验-perspective函数
小勇博客
08-03 609
— 2024-08-03 下午。
OpenGL坐标系
计算机技术交流
07-06 238
OpenGL使用的是右手笛卡尔坐标系统，Z正轴垂直屏幕向外，X正轴从左到右，Y正轴从下到上。 OpenGL中存下以下几种坐标系: 1.世界坐标系：世界坐标系以屏幕中心为原点(0, 0, 0)，在OpenGL中用来描述场景的坐标。比如使用这个坐标系来描述物体及光源的位置。世界坐标系，是不会被改变的。 2.模型坐标系：模型的绘制时使用的坐标系。当模型发生旋转平移等变化时，...
OpengGL教程(六)---坐标的变换和坐标系的变换
最新发布
玫瑰花店的博客
09-17 769
OpenGL坐标变化和坐标系变化演示
openGL坐标系
热门推荐
Benjamin's IT Life
09-17 3万+
OPENGL坐标系可分为：世界坐标系和当前绘图坐标系。 世界坐标系以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右边是x正轴，上面是y正轴，屏幕指向你的为z正轴。长度单位这样来定： 窗口范围按此单位恰好是(-1,-1)到(1,1)。 当前绘图坐标系是 绘制物体时的坐标系。程序刚初始化时，世界坐标系和当前绘图坐标系是重合的。当用glTranslatef()，glScalef(), glRotatef()对当前绘图坐标系进行平移、伸缩、旋转变换之后， 世界坐标系和当前绘图坐标系不再重合。改变以
OPENGL坐标系
ruixj的专栏
09-06 9837
openGL坐标系- -                                      openGL使用右手坐标从左到右，x递增从下到上，y递增从远到近，z递增OPENGL坐标系可分为：世界坐标系和当前绘图坐标系。世界坐标系以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右边是x正轴，上面是y正轴，屏幕指向你的为z正轴。长度单位这样来定： 窗口范围按此单位恰
openGL中的坐标系
m0_60259116的博客
04-22 7624
openGL中使用的是右手坐标系 右手坐标系：伸开右手，大拇指指向X轴正方向，食指指向Y轴正方向，其他三个手指指向Z轴正方向 左手坐标系：伸开左手，大拇指指向X轴正方向，食指指向Y轴正方向，其他三个手指指向Z轴正方向 两者的区别主要是两者Z轴的方向是相反的 一、坐标系 openGL中主要的几种坐标系 世界坐标系 以屏幕中心为原点(0,0,0)，当你面对屏幕时，右边是X正轴，上方是Y轴正轴，屏幕指向你的方向为Z轴正轴。窗口范围是从(-1,1)，即屏幕左下角坐标为(-1,-1,0)，右上
OpenGL中的坐标系
sinat_36772813的博客
03-04 1741
openGL中坐标系介绍
CoordinateSystems-05.zip
04-19
在实际的代码示例中，"CoordinateSystems-05.zip"可能包含了一些基本的OpenGL绘图函数，如glBegin()、glVertex()和glEnd()，以及用于设置矩阵和进行投影变换的函数，如glMatrixMode()、glLoadIdentity()、...
OpenGL学习笔记（5）----坐标系统、摄像机
LeonShaw_zh的博客
11-27 1923
OpenGL学习笔记（5）----坐标系统、摄像机引言坐标系统理论局部空间世界空间观察空间裁剪空间 引言 上一次笔记学习了OpenGL中的着色器的基本操作，纹理的使用，以及变换矩阵，我已经可以绘制出一个有纹理，会移动的2D三角形了。经过这一次的学习，我能够通过实现坐标系统将一个3D空间中的3D立方体绘制到屏幕空间中，还可以自定义摄像机类，在3D空间中自由移动。 坐标系统 先讲一些理论的东西。 理论...
OpenGL绘制三维坐标图
03-23
自制的基于MFC、OpenGL平台的三维坐标图程序，在vc2008编译通过
OpenGL坐标系讲解
12-17
非常系统的讲解关于使用OpenGL进行编程中，关于坐标系的介绍，是做工业建模、三维建模等不可少的资料，欢迎大家使用。
LearnOpenGL学习笔记—入门07：Coordinate Systems
清清！的博客
07-26 2895
LearnOpenGL学习笔记—入门07：Coordinate Systems0 前言1 坐标系统概述1.1 局部空间1.2 世界空间/模型矩阵1.3 观察空间/观察矩阵1.4 裁剪空间/投影矩阵1.4.1 正射投影1.4.2 透视投影1.5 总结2 代码实现 0 前言 本节笔记对应的内容 坐标系统 在入门01中我们配置好了环境 在入门02中我们可以检测输入并出现一个有颜色的窗口 在入门03中我们初步学习了图形渲染管线，尝试用不同方法画出了三角形和四边形 在入门04（上）中我们学习了shader和GLSL的
OpenGL 坐标系概览
anlz729的博客
05-18 8663
前言 前面我们总结了OpenGL的基本概念，下面我们着重理解一下OpenGL中的各种坐标系 一、笛卡尔坐标系 标题2D笛卡尔坐标系.png3D笛卡尔坐标系.png二、视口（Viewport） 世界窗口：在世界坐标系中定义一个对齐的矩形（aligned rectangle，即矩阵的边与坐标轴平行）的窗口，这个世界窗口外的部分被裁减并不被绘制。OpenGL会自动地做剪裁。 视口：在显示器的屏幕窗口上定义一个对齐的矩形的视口，OpenGL会自动建立世界窗口和视口的变换（包括缩放和平移）。当世界窗口中所有
openGL坐标变换
ruixj的专栏
09-06 3710
openGL坐标变换                                      坐标变换：OPENGL的每一种变换都是一个矩阵的运算。假设当前某顶点坐标为C，现在要做某种变换（设矩阵为M）得到新的坐标C1，那么运算过程就是C1＝T×C。OpenGL应用左乘规则,坐标的变换就是用变换矩阵乘以坐标向量OpenGL变换在编程的时候顺序是反过来的。想对目标 glutWireSp
Opengl 坐标
killallpigs的专栏
12-30 2633
继续 Learn Opengl 在流水线(Pipe line)中，物体的顶点在最终转化为屏幕坐标之前还会被变换到多个坐标系统。下图展示了整个流程: 局部空间 局部空间是指物体所在的坐标空间，即对象最开始所在的地方。想象你在一个建模软件中创建了一个立方体。你创建的立方体的原点有可能位于(0, 0, 0)，即便它有可能最后在程序中处于完全不同的位置。你的模型的所有顶点都是在局
2、OpenGL - 坐标系
shengdaVolleyball的博客
07-04 699
OpenGL - 坐标系 1、笛卡尔坐标 1.1、2D笛卡尔坐标系 平面坐标系，只有X 和 Y轴 1.2、3D笛卡尔坐标系 立体坐标系，有X Y轴还有Z 轴。形成立体3D图形 2、视口 在用户窗口中显示的大小，可以和原内容大小相同也可以不同 3、投影 光源的发出点称为 投影中心； 投影中心与物体上各点的连线称为 投影线； 接受投影的面，称为 投影面； 过物体上各点的投影线与投影面的交点称为这些点的投影。 投影分为 中心投影 和 平行投影 两大类。 ...
openGL 坐标系(1)
i53nd的专栏
05-30 1073
导读： 　　OpenGL中场景进行变换，要经历一些过程：视图变换à模型变换à投影变换，然后到了窗口坐标。这几个变换开始的时候把我搞很混，这几天整理一下。 　　一般书上把这几个变换用照相机类比，其实每个变换都是产生着一个4x4矩阵，然后与当前矩阵(Current Matrix)相乘，得到一个坐标变换矩阵，最后把世界坐标系（欧式空间）中的物体变换到屏幕坐标系中。这里梳理一下概念： 　　1、视图
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值