OpenGL（六）——坐标系统

news2025/1/16 3:42:58

目录

一、前言

二、空间系

2.1 局部空间

2.2 世界空间

2.3 观察空间

2.4裁剪空间

2.5 正射投影

2.6 透视投影

2.7 屏幕空间

 三、透视箱子

3.1 创建模型矩阵

3.2 创建观察矩阵

3.3 创建透视投影矩阵

3.4 修改顶点着色器

3.5 传递变换矩阵

四、旋转的箱子 

 五、好多箱子

一、前言

OpenGL显示的顶点在（-1，1）之间，这个坐标叫做标准化设别坐标（Normalized Device Coordinate， NDC）。将物体坐标变化到最终的NDC坐标需要几个过度坐标，在这些坐标系下计算非常容易和方便。过渡坐标分别在局部空间（物体空间）、世界空间、观察空间、裁剪空间、屏幕空间。

 物体坐标从一个坐标系变换到另一个坐标系需要用到几个变换矩阵，最重要的几个分别是模型(Model)、观察(View)、投影(Projection)三个矩阵。我们的顶点坐标起始于局部坐标(Local Coordinate)，之后会变为世界坐标(World Coordinate)，观察坐标(View Coordinate)，裁剪坐标(Clip Coordinate)，并以屏幕坐标(Screen Coordinate)的形式结束。

局部坐标：相对局部原点坐标，物体起始坐标，便于对物体本身进行修改

世界坐标：相对于世界全局原点，和其他物体一起相对于世界原点摆放，便于对一个物体的相对其它物体位置进行操作

观察空间坐标：相对于摄像机或者观察者的角度进行的

裁剪坐标：投影到裁剪空间，被处理至-1到1的范围，并判断哪些顶点出现在屏幕上

屏幕坐标：使用视口变换，将-1到1的坐标转换到glViewPort函数定义的坐标范围内，送给光栅器，转化为片段

二、空间系

2.1 局部空间

局部空间是指物体所在的坐标空间，模型都以（0，0，0）为初始位置，但是它们出现在世界的不同位置。模型的所有顶点都是在局部坐标系中，它们相对于你的物体来说都是局部的。

2.2 世界空间

将所有模型导入到程序中，每个模型物体都有自己的位置，需要定义世界空间原点，模型矩阵用来完成物体坐标从局部变换到世界空间。

模型矩阵：可以对物体进行位移、缩放、旋转它本应该在位置和朝向。

2.3 观察空间

观察空间也叫OpenGL摄像机，也称为摄像机空间、视觉空间。观察空间将世界空间坐标转化为用户视野前方坐标。

观察矩阵：世界空间变换到观察空间使用一系列位移、旋转等组合来完成。

2.4裁剪空间

在顶点着色器运行的最后，OpenGL期望所有坐标落在一个特定范围内（-1，1），范围外的点应该被剪掉（Clip）。屏幕上可见的片段叫做裁剪空间。

投影矩阵（projection Matrix）：将指定的坐标集（coordinate set）并将它变化为标准化设备坐标系。投影矩阵可以将3D坐标投影到2D标准化设备坐标中。

由投影矩阵创建的观察箱viewing box被称为平截头体，每个出现在平截头体范围内的坐标最终出现在屏幕上。

一旦所有顶点被变换到裁剪空间，将会执行透视除法，将位置向量的x,y,z分量除以向量齐次w分量。透视除法是将4D裁剪空间坐标变换为3D标准化设备坐标的过程。

观察坐标转换为裁剪坐标投影矩阵有两种形式：正射投影矩阵、透视投影矩阵

2.5 正射投影

正射投影定义一个裁剪空间，空间之外的顶点都会被裁剪掉。创建正射投影需要指定空间的长宽高。下图定义了可见坐标，由宽、高、远近平面指定。该空间内部所有坐标映射为标准设备坐标NDC。

创建正射投影矩阵：

glm::ortho(0.0f, 800.0f, 0.0f, 600.0f, 0.1f, 100.0f);
参数1：裁剪空间左坐标
参数2：裁剪空间右坐标
参数3：裁剪空间底部坐标
参数4：裁剪空间顶部坐标
参数5：近平面距离
参数6：远平面距离

 正射投影矩阵直接将坐标映射到2D平面（屏幕上），实际上一个直接投影矩阵会产生不真实结果，因为没有将透视（perspective）考虑进去。因此正射投影主要用于二维渲染以及一些建筑或者工程的程序，这些场景顶点不会被透视干扰。

2.6 透视投影

透视：立体空间中，近大远小的效果。透视使得两条平行线在远距离会相交，这是透视投影矩阵要完成的效果。

 透视投影矩阵将给定的平截头体映射到裁剪空间，还会修改每个顶点坐标w值，从而使离观察者越远的顶点坐标w分量越大。被变换到裁剪空间的坐标都会在(-w,w)范围内（超出范围坐标被剪掉）。

OpenGL要求所有可见坐标落在（-1，1）范围内，作为顶点着色器输出，当坐标在裁剪空间后，进行透视除法操作，近大远小：

 

 

glm::mat4 proj = glm::perspective(glm::radians(45.0f), (float)width/(float)height, 0.1f, 100.0f);
参数1：fov值，视野，设置观察空间大小
参数2：设置高宽比，视口宽除以高所得
参数3：平截头体近平面距离，0.1
参数4：平截头体远平面距离，100

2.7 屏幕空间

裁剪空间后的坐标映射到屏幕空间（glViewPort设定），并变换为片段。

一个顶点坐标将会经过下面变化，到裁剪坐标，注意矩阵运算顺序是相反的，最后顶点被赋值到gl_Position，OpenGL会自动对其进行透视除法变换到标准化设备坐标。OpenGL使用glViewPort内部的参数将NDC映射到屏幕坐标，每个坐标关联一个屏幕点，该过程称为视口变换。

 三、透视箱子

3.1 创建模型矩阵

位移、缩放、旋转操作。该模型矩阵将应用到所有物体顶点上，来映射到全局世界坐标。变换平面，让其绕x轴旋转。（当前位于原点（0，0，0））

 顶点乘以该模型矩阵，将顶点坐标变换到世界坐标，看起来在地板上，表示全局世界的平面。

glm::mat4 model;
model = glm::rotate(model,glm::radians(-55.0f),glm::vec3(1.0,0.0,0.0));

3.2 创建观察矩阵

想要在场景里移动，可以将摄像机向后移动，或者将整个场景向前移动。以相反与摄像机移动的方向移动整个场景。OpenGL是右手坐标系，当我们要沿z轴正方向移动时，我们将场景沿z轴负方向平移来实现。

右手坐标系 大拇指指向正x轴方向，食指指向正y轴方向，中指指向正z轴方向（DirectX使用左手坐标系）注意在标准化设备坐标系中OpenGL实际上使用的是左手坐标系（投影矩阵交换了左右手）。

glm:mat4 view;
// 注意，我们将矩阵向我们要进行移动场景的反方向移动
view = glm::translate(view,glm::vec3(0.0,0.0,-3.0));

3.3 创建透视投影矩阵

glm::mat4 projection;
projection = glm::perspective(glm::radians(45.0f), screenWidth/screenHight,0.1,100.0);

3.4 修改顶点着色器

使用uniform声明变换矩阵，然后乘以顶点坐标：

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
layout (location = 2) in vec2 aTexCoord;

out vec3 ourColor;
out vec2 TexCoord;

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

void main()
{
    // 注意乘法要从右向左读
	gl_Position = projection*view*model*vec4(aPos, 1.0);
	ourColor = aColor;
	TexCoord = vec2(aTexCoord.x, aTexCoord.y);
}

3.5 传递变换矩阵

        //model matrix
        glm::mat4 modelMat = glm::mat4(1.0f);
        modelMat = glm::rotate(modelMat, glm::radians(-55.0f), glm::vec3(1.0, 0.0, 0.0));
        //view matrix
        glm::mat4 viewMat = glm::mat4(1.0f);
        viewMat = glm::translate(viewMat, glm::vec3(0.0f, 0.0f, -3.0f));
        //projection matrix
        glm::mat4 projectionMat = glm::mat4(1.0f);
        projectionMat = glm::perspective(glm::radians(45.0f), (float)(SCR_WIDTH / SCR_HEIGHT), 0.1f, 100.0f);
        //着色器引用
        ourShader.use();
        unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
        glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMat));
        unsigned int viewlLoc = glGetUniformLocation(ourShader.ID, "view");
        glUniformMatrix4fv(viewlLoc, 1, GL_FALSE, glm::value_ptr(viewMat));
        unsigned int projectionlLoc = glGetUniformLocation(ourShader.ID, "projection");
        glUniformMatrix4fv(projectionlLoc, 1, GL_FALSE, glm::value_ptr(projectionMat));

四、旋转的箱子 

3D箱子顶点：

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

修改模型矩阵：

        glm::mat4 modelMat = glm::mat4(1.0f);
        //modelMat = glm::rotate(modelMat, glm::radians(-55.0f), glm::vec3(1.0, 0.0, 0.0));//model matrix
        modelMat = glm::rotate(modelMat, (float)glfwGetTime(), glm::vec3(0.5f, 1.0f, 0.0f));

解释VAO数据：

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

 立方体某些本应遮挡住的面被绘制在立方体其他面上。OpenGL是一个三角形一个三角形绘制立方体，即便有东西也会覆盖之前的像素。OpenGL存储深度信息在Z缓冲中，允许OpenGL是否去执行覆盖像素。通过Z缓冲来配置OpenGL深度测试。

GLFW会自动生成一个深度缓冲，深度值存储在每个片段里面，当片段要输出它的颜色时，OpenGL将它的深度值与Z缓冲进行比较，如果当前片段在其他片段之后会被丢失，否则会被覆盖。

glEnable(GL_DEPTH_TEST);//glDisable关闭

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//清除深度缓冲

 五、好多箱子

要在屏幕上显示10个立方体，每个立方体看起来是一样的，区别是世界位置和旋转角度不同。立方体图形布局已经定义好了，只需改变每个对象的模型矩阵来将立方体变换到世界坐标中。

定义每个立方体的位置：

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

渲染主循环中循环绘制cubePositions

glBindVertexArray(VAO);
for(unsigned int i = 0; i < 10; i++)
{
  glm::mat4 model;
  model = glm::translate(model, cubePositions[i]);
  float angle = 20.0f * i; 
  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 <iostream>
#include <string>

#include "glad.h"
#include "GL/glfw3.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "Shader.h"
// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

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

int main()
{
    // glfw: 初始化、配置
    // ------------------------------
    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: 创建窗口、绑定回调
    // --------------------
    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: 加载OpenGL相关函数指针
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }
    // 构建、编译着色器
    // ------------------------------------
    Shader ourShader("vertexTexture.vs", "fragmentTexture.fms");
    // 顶点数据
    // ------------------------------------------------------------------
    /*float vertices[] = {
        // 位置                 // 纹理坐标
         0.5f,  0.5f, 0.0f,     1.0f, 1.0f, // top right
         0.5f, -0.5f, 0.0f,     1.0f, 0.0f, // bottom right
        -0.5f, -0.5f, 0.0f,     0.0f, 0.0f, // bottom left
        -0.5f,  0.5f, 0.0f,     0.0f, 1.0f  // top left 
    };
    unsigned int indices[] = {
        0, 1, 3, // 第一个三角形
        1, 2, 3  // 第二个三角形
    };*/
    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
    };
    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)
    };
    //创建顶点对象
    unsigned int VAO, VBO, EBO;
    glGenVertexArrays(1, &VAO);//顶点数组
    glGenBuffers(1, &VBO);//数据缓存
    //glGenBuffers(1, &EBO);//数据缓存
    //绑定数据
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    //glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    //解释数据
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);//位置
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));//纹理
    glEnableVertexAttribArray(1);
    //创建纹理对象1
    unsigned int texture1;
    glGenTextures(1, &texture1);
    glBindTexture(GL_TEXTURE_2D, texture1);
    //设置纹理环绕方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    //设置纹理过滤方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    //加载图片1到纹理数据
    int width, height, nrChannels;
    unsigned char* data = stbi_load(std::string("container.jpg").c_str(), &width, &height, &nrChannels, 0);
    if (data)
    {
        //加载数据，生成OpenGL纹理图
        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);
    //创建纹理对象2
    unsigned int texture2;
    // texture 2
// ---------
    glGenTextures(1, &texture2);
    glBindTexture(GL_TEXTURE_2D, texture2);
    // set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	// set texture wrapping to GL_REPEAT (default wrapping method)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // load image, create texture and generate mipmaps
    stbi_set_flip_vertically_on_load(true);
    data = stbi_load(std::string("awesomeface.png").c_str(), &width, &height, &nrChannels, 0);
    if (data)
    {
        // note that the awesomeface.png has transparency and thus an alpha channel, so make sure to tell OpenGL the data type is of GL_RGBA
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 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("textur1", 0);
    ourShader.setInt("textur2", 1);
    glEnable(GL_DEPTH_TEST);
    //旋转90度，缩放0.5倍
    //glm::mat4 trans = glm::mat4(1.0f);
   // trans = glm::rotate(trans, glm::radians(90.0f), glm::vec3(0, 0, 1.0));
    //trans = glm::scale(trans, glm::vec3(0.5, 0.5, 0.5));

    //渲染
    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);
        //glm::mat4 modelMat = glm::mat4(1.0f);
        glm::mat4 viewMat = glm::mat4(1.0f);
        glm::mat4 projectionMat = glm::mat4(1.0f);
        //modelMat = glm::rotate(modelMat, glm::radians(-55.0f), glm::vec3(1.0, 0.0, 0.0));//model matrix
        //modelMat = glm::rotate(modelMat, (float)glfwGetTime(), glm::vec3(0.5f, 1.0f, 0.0f));
        viewMat = glm::translate(viewMat, glm::vec3(0.0f, 0.0f, -3.0f));//view matrix 
        projectionMat = glm::perspective(glm::radians(45.0f), (float)(SCR_WIDTH / SCR_HEIGHT), 0.1f, 100.0f);//projection matrix
        //着色器引用
        ourShader.use();
        //unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
        //glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMat));
        unsigned int viewlLoc = glGetUniformLocation(ourShader.ID, "view");
        glUniformMatrix4fv(viewlLoc, 1, GL_FALSE, glm::value_ptr(viewMat));
        unsigned int projectionlLoc = glGetUniformLocation(ourShader.ID, "projection");
        glUniformMatrix4fv(projectionlLoc, 1, GL_FALSE, glm::value_ptr(projectionMat));
        //绘图
        glBindVertexArray(VAO);
        //glDrawArrays(GL_TRIANGLES, 0, 36);
        for (unsigned int i = 0; i < 10; i++)
        {
            glm::mat4 modelMat = glm::mat4(1.0f);
            modelMat = glm::translate(modelMat, cubePositions[i]);
            modelMat = glm::rotate(modelMat, (float)glfwGetTime(), glm::vec3(1.0f, 0.3f, 0.5f));
            ourShader.setMat4("model", modelMat);
            glDrawArrays(GL_TRIANGLES, 0, 36);
        }

        //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        /*
        * 
        void glDrawElements(	GLenum mode,
 	    GLsizei count,
 	    GLenum type,
 	    const GLvoid * indices);
        */
        //刷新
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    //释放缓存资源
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);
    //释放glfw资源
    glfwTerminate();

    return 0;
}

参考：

坐标系统 - LearnOpenGL CN (learnopengl-cn.github.io)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/491426.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

面了一圈，还没拿到offer.....

面了一圈，还没拿到offer.....

最近收到很多小伙伴的留言&#xff0c;金三银四过完了一个offer都没收到。还有遇到那种特别喜欢怼人的面试官&#xff0c;直接面到怀疑人生&#xff0c;真是让人费解。。。 其实面试受打击是正常的&#xff0c;关键是要在面试中总结自己的不足&#xff01;提前做好面试准备和技…
阅读更多...
java基于知识库的中医药问询系统

java基于知识库的中医药问询系统

本系统主要包含了等系统用户管理、中医药常识管理、科室信息管理、知识库管理多个功能模块。下面分别简单阐述一下这几个功能模块需求。 管理员的登录模块&#xff1a;管理员登录系统对本系统其他管理模块进行管理。 用户的登录模块&#xff1a;用户登录本系统&#xff0c;对个…
阅读更多...
简历投了2个月没有面试，看这趋势，不发力是不行了

简历投了2个月没有面试，看这趋势，不发力是不行了

最近有朋友吐槽&#xff0c;感觉最近好难&#xff0c;简历投了2个月了&#xff0c;面试机会很少&#xff0c;自己每天也费心费力的投&#xff0c;一有新职位就赶紧投&#xff0c;自己也积极的跟人家打招呼&#xff0c;不是看完那边没有回复&#xff0c;要么就是不合适。于是我就…
阅读更多...
基于ARM树莓派实现智能家居：语音识别控制，Socket网络控制，火灾报警检测，实时监控

基于ARM树莓派实现智能家居：语音识别控制，Socket网络控制，火灾报警检测，实时监控

目录 一 项目说明 ① 设计框架 ② 功能说明 ③ 硬件说明 ④ 软件说明 二 项目代码 <1> mainPro.c 主函数 <2> InputCommand.h 控制设备头文件 <3> contrlDevices.h 外接设备头文件 <4> bathroomLight.c 泳池灯 <5> livin…
阅读更多...
【GUI】基于Python的文本数据处理（串口解析 0D 0A结尾）

【GUI】基于Python的文本数据处理（串口解析 0D 0A结尾）

【GUI】基于Python的文本数据处理&#xff08;串口解析 0D 0A结尾&#xff09; 如有串口数据&#xff1a; [37;22mD/NO_TAG [2023-04-24 23:01:06 ] ------------------------------------------------->>>>>> M_DADAT_GET_DAMAGE_INFO [0m 2023/04/24 2…
阅读更多...
200左右什么蓝牙耳机比较好？国产200左右蓝牙耳机推荐

200左右什么蓝牙耳机比较好？国产200左右蓝牙耳机推荐

随着不少手机厂商取消3.5mm耳机孔&#xff0c;蓝牙耳机便成为了人们外出的最佳选择。最近看到很多人问&#xff0c;200左右什么蓝牙耳机比较好&#xff1f;针对这个问题&#xff0c;我来给大家推荐几款国产的蓝牙耳机&#xff0c;一起来看看吧。 一、南卡小音舱Lite2蓝牙耳机 …
阅读更多...
如何防止订单重复支付

如何防止订单重复支付

想必大家对在线支付都不陌生&#xff0c;今天和大家聊聊如何防止订单重复支付。 看看订单支付流程 我们来看看&#xff0c;电商订单支付的简要流程&#xff1a; 订单钱包支付流程 从下单/计算开始&#xff1a; 下单/结算&#xff1a;这一步虽然不是直接的支付起点&#xff0c;但…
阅读更多...
opencv场景识别

opencv场景识别

opencv场景识别 文章目录 一、需求1、现状2、设想 二、模型使用1、opencv dnn支持的功能2、ANN_MLP相关知识3、MLP图像分类模型训练学习 三、更换方向1、目标检测模型2、darknet网络介绍 四、opencv调用darknet模型1、**darknet模型获取**2、python调用darknet模型3、遇到的一些…
阅读更多...
NewBing最新更新使用体验（无需等待人人可用）

NewBing最新更新使用体验（无需等待人人可用）

NewBing最新更新使用体验 微软Bing爆炸级更新&#xff01;无需等待人人可用&#xff01; 今天&#xff0c;微软突然官宣全面开放BingChat&#xff1a; 无需任何等待。只需注册一个账户&#xff0c;首页即可体验。 NewBing最新更新新特性官方文档 https://www.microsoft.com/en-…
阅读更多...
ETL 组件Spark资源设置指导

ETL 组件Spark资源设置指导

一、概念介绍 1.RDD RDD&#xff08;Resilient Distributed Dataset&#xff09;:弹性分布式数据集&#xff0c;是Spark中最基础的数据抽象。它本质就是一个类&#xff0c;屏蔽了底层对数据的复杂抽象和处理&#xff0c;为用户提供了一组方便数据转换和求值的方法。 简单来说…
阅读更多...
研报精选230505

研报精选230505

目录 【行业230505国信证券】风电or电网产业链周评&#xff08;4月第5周&#xff09;&#xff1a;海风开发资源集中释放&#xff0c;黑色类原材料价格持续下行 【行业230505天风证券】通信AI系列之&#xff1a;人工智能之火点燃算力需求&#xff0c;AI服务器迎投资机遇 【行业2…
阅读更多...
数字孪生遇上VR：未来的新生态

数字孪生遇上VR：未来的新生态

数字孪生和虚拟现实&#xff08;VR&#xff09;是当今技术领域备受关注的两个概念。 数字孪生作为物理世界的数字映像&#xff0c;已经在许多行业得到了广泛应用。而VR则是一种基于计算机生成的三维交互式虚拟环境&#xff0c;被广泛应用于娱乐、教育和游戏等领域。 数字孪生…
阅读更多...
十一、MyBatis的逆向工程

十一、MyBatis的逆向工程

文章目录 十一、MyBatis的逆向工程11.1 (清新简洁版)创建逆向工程的步骤11.2 (奢华尊享版)创建逆向工程的步骤11.3 说明尊享版和简洁版的区别 本人其他相关文章链接 十一、MyBatis的逆向工程 正向工程&#xff1a;先创建Java实体类&#xff0c;由框架负责根据实体类生成数据库…
阅读更多...
Spring MVC程序开发

Spring MVC程序开发

文章目录 一、什么是 Spring MVC&#xff08;一&#xff09;MVC的定义&#xff08;二&#xff09;MVC 和 Spring MVC 的关系&#xff08;三&#xff09;为什么要学习 Spring MVC 二、Spring MVC使用方法和技巧&#xff08;一&#xff09;Spring MVC 创建和连接&#xff08;二&a…
阅读更多...
clonezilla(再生龙)克隆系统操作

clonezilla(再生龙)克隆系统操作

一、前言 背景&#xff1a;由于存在对嵌入式设备系统备份的需求&#xff0c;主要使用在对一个嵌入式设备安装好ros以及其他插件&#xff08;安装时间十分冗长&#xff09;&#xff0c;然后对该系统进行备份&#xff0c;快速复制到下一台嵌入式设备中。因此引出了克隆linux系统…
阅读更多...
MySQL知识学习08（MySQL自增主键一定是连续的吗）

MySQL知识学习08（MySQL自增主键一定是连续的吗）

众所周知&#xff0c;自增主键可以让聚集索引尽量地保持递增顺序插入&#xff0c;避免了随机查询&#xff0c;从而提高了查询效率。 但实际上&#xff0c;MySQL 的自增主键并不能保证一定是连续递增的。 下面举个例子来看下&#xff0c;如下所示创建一张表&#xff1a; 1、自…
阅读更多...
C++类与对象（二）——拷贝构造函数

C++类与对象（二）——拷贝构造函数

文章目录 拷贝构造函数1.拷贝构造函数的概念2.拷贝构造函数的特性 前言 本章继续学习类的6个默认成员函数——拷贝构造函数 拷贝构造函数 1.拷贝构造函数的概念 拷贝构造函数&#xff1a;使用已经存在的一个对象初始化创建另一个对象。 举例&#xff1a; class Date { publ…
阅读更多...
Golang每日一练(leetDay0056) 单个编辑距离、寻找峰值

Golang每日一练(leetDay0056) 单个编辑距离、寻找峰值

目录 161. 单个编辑距离 One Edit Distance &#x1f31f;&#x1f31f; 162. 寻找峰值 Find Peak Element &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 …
阅读更多...
vmware 安装Kylin-Desktop-V10-SP1-General-Release-2203-X86_64.iso

vmware 安装Kylin-Desktop-V10-SP1-General-Release-2203-X86_64.iso

下载 官网&#xff1a;国产操作系统、银河麒麟、中标麒麟、开放麒麟、星光麒麟——麒麟软件官方网站 (kylinos.cn) 点击桌面操作系统 选择No1 点击申请试用 填写相关信息&#xff0c;点击立即提交&#xff0c;就会获取到下载连接&#xff0c; 点击下载按钮等待下载完成即可 安…
阅读更多...
Java中顺序表详解

Java中顺序表详解

前言 在Java编程中&#xff0c;顺序表是一种基础且重要的数据结构。它通常用来表示线性结构数据&#xff0c;如数组等。通过使用顺序表&#xff0c;我们可以轻松管理和操作大量的数据&#xff0c;并实现各种算法和功能。本篇博客将详细介绍Java中顺序表相关的原理、方法和实例&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023