OpenGL学习脚印：缓冲对象相关函数的使用(buffer object function usage)

最新推荐文章于 2024-10-15 20:29:18 发布
转载 最新推荐文章于 2024-10-15 20:29:18 发布 · 342 阅读 · 0

本文转自点击打开链接，作者是the fool


OpenGL中还包含除了我们前面介绍的VAO,VBO,EBO等其他类型的缓冲对象。关于如何使用这些缓冲对象的手册或者参考书籍上解释得非常详细，但是阅读起来确实很枯燥无味。 
本文将通过简洁、可靠的例子说明一些重要方法的使用，以辅助学习这些方法。本文的目的不是写成详细而厚重的手册，对于文中未详细说明的部分，请参考官方文档。 
学习这些内容的过程需要随着实践慢慢积累，因此本文也将随着实践进行，不断更新。本节示例代码均可以在我的github下载。

buffer object的概念

在OpenGL中，缓存对象(buffer object)是由OpenGL的绘制上下文(context)，也即是GPU分配的，存储未格式化的数据的区域，例如存储顶点数据，帧缓冲数据等。

缓存对象中的数据实际上就是原始的字节流，例如我们在程序中指定顶点属性数据，然后使用glBufferData​这个函数将数据从CPU中传送至GPU中，这一步只完成了数据的上传，关于这份数据，OpenGL是不知道其具体格式的，因此在实际使用中还必须告诉OpenGL如何具体使用这些数据，这是通过glVertexAttribPointer这样的函数来完成的。

每个缓存对象，必须绑定到一个具体的目标(target)后，OpenGL才知道如何具体操作这个缓存对象，例如绑定到GL_ARRAY_BUFFER，OpenGL使用这个缓存对象作为顶点属性数据；例如绑定到GL_ELEMENT_ARRAY_BUFFER，则OpenGL使用这个缓存对象的数据作为索引绘图的索引数据。

缓存对象的数据，也存在读写、复制、清除等操作，同时缓存对象在适当时候也可以使用 glDeleteBuffers​这类函数释放。

下面通过简洁的例子介绍一些重要方法的使用。

glVertexAttribPointer

这个函数的使用容易引起一些混淆，尤其是末尾两个参数。

API void glVertexAttribPointer( GLuint index, 
GLint size, 
GLenum type, 
GLboolean normalized, 
GLsizei stride, 
const GLvoid * pointer); 
1. 参数index 表示顶点属性的索引 这个索引即是在顶点着色器中的属性索引，索引从0开始记起。 
2. 参数size 每个属性数据由几个分量组成。例如上面顶点每个属性为3个float组成的，size即为3。分量的个数必须为1,2,3,4这四个值之一。 
3. 参数type表示属性分量的数据类型，例如上面的顶点数据为float则填写GL_FLOAT. 
4. 参数normalized 表示是否规格化，当存储整型时，如果设置为GL_TRUE,那么当被以浮点数形式访问时，有符号整型转换到[-1,1],无符号转换到[0,1]。否则直接转换为float型，而不进行规格化。 
5. 参数stride表示连续的两个顶点属性之间的间隔，以字节大小计算。当顶点属性紧密排列时，可以用初始值为0，这时OpenGL将自动推算出stride。 
6. 参数pointer表示当前绑定到的 GL_ARRAY_BUFFER缓冲区中，顶点属性的第一个分量在数据中的偏移量，以字节为单位计算。初始值为0。

这个函数末尾的两个参数，stride表示缓存对象中连续两个顶点属性之间的间隔，而offset则表示顶点属性的第一个分量在这儿缓存对象数据中的位置偏移量。具体的计算第 i 个分量的方式为(参考自SO)：

startPos(i)=offset+i∗stride(顶点属性位置计算)

例如下图中给定的交错形式的顶点属性数据，对应的顶点属性位置如下：

顶点属性位置计算

例如计算第三个颜色rgb的开始位置为： 
12+2∗(32)=76 。

三种传送顶点属性数据的方式

这里以绘制一个三角形为例，这个三角形包含的顶点属性包括：位置、颜色、以及纹理坐标，着色器中将颜色和纹理进行混合。

有了上面对glVertexAttribPointer的理解，我们可以有三种方式传送顶点数据：

  • 为每个顶点属性指定一个独立的VBO

  • 单个顶点属性连续存放，整个顶点属性作为一个一个VBO

  • 顶点属性之间交错存放，整体作为一个VBO

这三种方式都是支持的，通过这三种方式的实现，我们加深对glVertexAttribPointer的理解。

方式一 指定多个VBO的方式

存放格式为： (xyzxyz)(rgbrgb) (stst) 
实现代码为:

   // 顶点属性每个独立的VBO
void prepareVertData_moreVBO(GLuint& VAOId, std::vector<GLuint>& VBOIdVec)
{
    // 单个属性独立
GLfloat vertPos[] = {
        -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f,  // 顶点位置
    };
GLfloat vertColor[] = {
    1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,   // 颜色
};
GLfloat vertTextCoord[] = {
    0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f     // 纹理坐标
};
    // 创建缓存对象
    GLuint VBOId[3];
    // Step1: 创建并绑定VAO对象
    glGenVertexArrays(1, &VAOId);
    glBindVertexArray(VAOId);
    glGenBuffers(3, VBOId);
    // 顶点位置属性
    glBindBuffer(GL_ARRAY_BUFFER, VBOId[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertPos), vertPos, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(0);
    // 顶点颜色属性
    glBindBuffer(GL_ARRAY_BUFFER, VBOId[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertColor), vertColor, GL_STATIC_DRAW);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(1);
    // 顶点纹理坐标
    glBindBuffer(GL_ARRAY_BUFFER, VBOId[2]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertTextCoord), vertTextCoord, GL_STATIC_DRAW);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    VBOIdVec.push_back(VBOId[0]);
    VBOIdVec.push_back(VBOId[1]);
    VBOIdVec.push_back(VBOId[2]);
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

注意这种方式下stride和offset参数都填写为0，由OpenGL推算出stride值，例如颜色属性的stride推算为: 3 * sizeof(GLfloat) = 12。

方式二 连续存放作为一个VBO

格式为： (xyzxyz… rgbrgb… stst…) 
实现为:

   // 顶点属性单个连续的整体VBO
void prepareVertData_seqBatchVBO(GLuint& VAOId, std::vector<GLuint>& VBOIdVec)
{
    // 单个属性连续作为整体
    GLfloat vertices[] = {
-0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f,  // 顶点位置
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,   // 颜色
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f     // 纹理坐标
    };
    // 创建缓存对象
    GLuint VBOId;
    // Step1: 创建并绑定VAO对象
    glGenVertexArrays(1, &VAOId);
    glBindVertexArray(VAOId);
    // Step2: 创建并绑定VBO 对象 传送数据
    glGenBuffers(1, &VBOId);
    glBindBuffer(GL_ARRAY_BUFFER, VBOId);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    // Step3: 指定解析方式  并启用顶点属性
    // 顶点位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); // 紧密排列 stride也可以设置为 3 * sizeof(GL_FLOAT)
    glEnableVertexAttribArray(0);
    // 顶点颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)(9 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(1);
    // 顶点纹理坐标
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*)(18 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    VBOIdVec.push_back(VBOId);
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

注意 这里单个属性依然是紧密排列，所以stride值可以填写0；但是属性之间的offset需要手动计算出来，不能再填写为0了。

方式三 交错排列使用一个VBO

格式为：（xyzrgbst xyzrgbst…） 
实现为：

   // 顶点属性之间交错的整体VBO
void prepareVertData_interleavedBatchVBO(GLuint& VAOId, std::vector<GLuint>& VBOIdVec)
{
    // 交错指定顶点属性数据
    GLfloat vertices[] = {
    // 顶点位置 颜色 纹理纹理
    -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,  // 0
    0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,  // 1
    0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,  // 2
    };
    // 创建缓存对象
    GLuint VBOId;
    // Step1: 创建并绑定VAO对象
    glGenVertexArrays(1, &VAOId);
    glBindVertexArray(VAOId);
    // Step2: 创建并绑定VBO 对象 传送数据
    glGenBuffers(1, &VBOId);
    glBindBuffer(GL_ARRAY_BUFFER, VBOId);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    // Step3: 指定解析方式  并启用顶点属性
    // 顶点位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,8 * sizeof(GL_FLOAT), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    // 顶点颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
        8 * sizeof(GL_FLOAT),(GLvoid*)(3 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(1);
    // 顶点纹理坐标
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 
        8 * sizeof(GL_FLOAT), (GLvoid*)(6 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    VBOIdVec.push_back(VBOId);
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

需要注意的是这里的stride和offset都需要手动计算出来，不能依赖默认值0了。如果stride这里填写0，OpenGL将无法推算出来，导致渲染不出来三角形。

对于这三种方式的性能对比，尚没有做测试。OpenGL官方文档描述性能差异不明确。根据需要，你可以选取其中的一种方式来实现你要的功能。

上面绘制的混色三角形，如下图所示：

混色三角形

使用glBufferSubData

前面都是分配了一个VBO，然后将顶点属性数据直接拷贝到整个VBO，实际上可以先为VBO分配空间，然后根据需要更新VBO中一段内容，这里使用到的方法就是glBufferSubData。

API void glBufferSubData( GLenum target, 
GLintptr offset, 
GLsizeiptr size, 
const GLvoid * data); 
1.target 绑定到的目标对象 
2.在缓存对象中的偏移 
3.指定更改的数据大小 
4.用指针指定原始数据的位置

例如上面绘制三角形例子中，我们先分配一个大的VBO，然后将多个顶点属性分配拷贝至这个VBO，实现为:

   // 使用glBufferSubData完成VBO
void prepareVertData_glBufferSubData(GLuint& VAOId, std::vector<GLuint>& VBOIdVec)
{
    // 单个属性独立
    GLfloat vertPos[] = {
        -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f,  // 顶点位置
    };
    GLfloat vertColor[] = {
        1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,   // 颜色
    };
    GLfloat vertTextCoord[] = {
        0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f     // 纹理坐标
    };
    // 创建缓存对象
    GLuint VBOId;
    // Step1: 创建并绑定VAO对象
    glGenVertexArrays(1, &VAOId);
    glBindVertexArray(VAOId);
    // Step2: 创建并绑定VBO 对象 预分配空间
    glGenBuffers(1, &VBOId);
    glBindBuffer(GL_ARRAY_BUFFER, VBOId);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertPos)+sizeof(vertColor) + sizeof(vertTextCoord), 
        NULL, GL_STATIC_DRAW);  // 预分配空间
    // Step3: 填充具体的数据
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertPos), vertPos);
    glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertPos), sizeof(vertColor), vertColor);
    glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertPos)+ sizeof(vertColor), sizeof(vertTextCoord), vertTextCoord);
    // Step4: 指定解析方式  并启用顶点属性
    // 顶点位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); // 紧密排列 stride也可以设置为 3 * sizeof(GL_FLOAT)
    glEnableVertexAttribArray(0);
    // 顶点颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)(9 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(1);
    // 顶点纹理坐标
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*)(18 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    VBOIdVec.push_back(VBOId);
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

注意代码中使用glBufferData的第三个参数为NULL时，为预分配空间，在使用glBufferSubData时一定要预分配空间。

glMapBuffer

有些时候我们想直接获取缓存对象的数据空间，这时可以通过glMapBuffer这个函数和其配对的glUnmapBuffer函数实现。

API void *glMapBuffer( GLenum target, 
GLenum access); 
1.指定要映射的目标对象 
2.指定映射的读写策略，为枚举值GL_READ_ONLY, GL_WRITE_ONLY，或者 GL_READ_WRITE。

例如上面绘制三角形中，我们将GL_ARRAY_BUFFER映射后，获取到缓存对象的内存指针后，我们将数据拷贝到GL_ARRAY_BUFFER中，实现为：

   // 使用glMapBuffer
void prepareVertData_glMapBuffer(GLuint& VAOId, std::vector<GLuint>& VBOIdVec)
{
    // 交错指定顶点属性数据
    GLfloat vertices[] = {
        // 顶点位置 颜色 纹理纹理
        -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,  // 0
        0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,  // 1
        0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,  // 2
    };
    // 创建缓存对象
    GLuint VBOId;
    // Step1: 创建并绑定VAO对象
    glGenVertexArrays(1, &VAOId);
    glBindVertexArray(VAOId);
    // Step2: 创建并绑定VBO 对象
    glGenBuffers(1, &VBOId);
    glBindBuffer(GL_ARRAY_BUFFER, VBOId);
    // Step3: 映射数据
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), NULL, GL_STATIC_DRAW); // 预分配空间
    void* ptr = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
    if (!ptr)
    {
        std::cerr << " map buffer failed!" << std::endl;
        return;
    }
    memcpy(ptr, vertices, sizeof(vertices));  // 可以操作这个指针指向的内存空间
    glUnmapBuffer(GL_ARRAY_BUFFER);
    // Step4: 指定解析方式  并启用顶点属性
    // 顶点位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GL_FLOAT), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    // 顶点颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
        8 * sizeof(GL_FLOAT), (GLvoid*)(3 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(1);
    // 顶点纹理坐标
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE,
        8 * sizeof(GL_FLOAT), (GLvoid*)(6 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    VBOIdVec.push_back(VBOId);
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

需要注意的是如果要拷贝数据到这个映射后的内存指针指向的空间上，一定要提前为缓存对象预分配空间，否则将无法复制数据。

glCopyBufferSubData

glCopyBufferSubData这个函数可以用于缓存对象之间拷贝数据。

API void glCopyBufferSubData( GLenum readTarget, 
GLenum writeTarget, 
GLintptr readOffset, 
GLintptr writeOffset, 
GLsizeiptr size); 
1.readTarget指定读数据的目标 
2.writeTraget指定写数据的目标 
3.readOffset指定读取数据时的起始偏移量 
4.writeOffset指定写入数据时的偏移量 
5.size指定拷贝数据的大小

作为函数方法使用的一个演示，我们将顶点属性数据首先通过glMapBuffer读入到GL_COPY_WRITE_BUFFER，然后通过glCopyBufferSubData将数据从GL_COPY_WRITE_BUFFER拷贝到GL_ARRAY_BUFFER。实现为：

   // 使用glCopyBufferSubData 
void prepareVertData_glCopyBufferSubData(GLuint& VAOId, std::vector<GLuint>& VBOIdVec)
{
    // 交错指定顶点属性数据
    GLfloat vertices[] = {
    // 顶点位置 颜色 纹理纹理
    -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,  // 0
    0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,  // 1
    0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,  // 2
    };
    // 创建缓存对象
    GLuint VBOId;
    // Step1: 创建并绑定VAO对象
    glGenVertexArrays(1, &VAOId);
    glBindVertexArray(VAOId);
    // Step2: 创建并绑定VBO 对象
    glGenBuffers(1, &VBOId);
    glBindBuffer(GL_ARRAY_BUFFER, VBOId);
    GLuint TempBufferId;
    glGenBuffers(1, &TempBufferId);
    glBindBuffer(GL_COPY_WRITE_BUFFER, TempBufferId);
    // Step3: 映射数据到GL_COPY_WRITE_BUFFER
    glBufferData(GL_COPY_WRITE_BUFFER, sizeof(vertices), NULL, GL_STATIC_DRAW); // 预分配空间
    void* ptr = glMapBuffer(GL_COPY_WRITE_BUFFER, GL_WRITE_ONLY);
    if (!ptr)
    {
        std::cerr << " map buffer failed!" << std::endl;
        return;
    }
    memcpy(ptr, vertices, sizeof(vertices));  // 可以操作这个指针指向的内存空间
    glUnmapBuffer(GL_COPY_WRITE_BUFFER);
    // Step4: 将数据拷贝到VBO
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), NULL, GL_STATIC_DRAW); // 注意拷贝前预分配空间
    glCopyBufferSubData(GL_COPY_WRITE_BUFFER, GL_ARRAY_BUFFER, 0, 0, sizeof(vertices));
    glDeleteBuffers(1, &TempBufferId);
    // Step5: 指定解析方式  并启用顶点属性
    // 顶点位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GL_FLOAT), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    // 顶点颜色属性
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
        8 * sizeof(GL_FLOAT), (GLvoid*)(3 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(1);
    // 顶点纹理坐标
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE,
        8 * sizeof(GL_FLOAT), (GLvoid*)(6 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(2);

    glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    VBOIdVec.push_back(VBOId);
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

后面还有其他方法，等待实践， 未完待续…

参考资料

1.OpenGL SuperBible: Comprehensive Tutorial and Reference 
2.OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3 
3.Vertex Specification 
4.Data in OpenGL Buffers 
5.Buffer Object 
6.Vertex Specification Best Practices






CUDA： OpenGL绑定 使用Cuda内核动态修改顶点缓冲区实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-22 260
CUDA： OpenGL绑定 使用Cuda内核动态修改顶点缓冲区实例
openGL学习-7（顶点缓冲对象，顶点数组对象）
liujianfeng123a的博客
07-09 739
(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。从这一刻起，我们使用的任何（在GL_ARRAY_BUFFER目标上的）缓冲调用都会用来配置当前绑定的缓冲(VBO)。当我们打算绘制物体的时候就拿出相应的VAO，绑定它，绘制完物体后，再解绑VAO。
OpenGL缓冲对象 Buffer Objects
01-21 983
Buffer Objects（缓冲对象）是OpenGL中的一个重要概念，用于存储大量数据并高效地传输到图形处理器（GPU）。它们可以用来保存顶点、索引、纹理数据等各种类型的图形渲染所需的数据。：在现代OpenGL中，SSBO用于在GPU内存中存储大量数据，并允许着色器直接读写这些数据。：用于存储传递给着色器程序的全局或共享的uniform变量数据，提高频繁更新uniform变量时的效率。：分别用于像素数据的输入/输出操作和将一维纹理数据存储在缓冲对象中，实现高效的纹理上传和下载。
buffer object 的使用
hello
04-27 668
1.要包含glew.h的头文件 2.要
OpenGL Buffer Object
BugRunner的专栏
03-08 6708
OpenGL的缓冲对象提供了一种高效的数据操作及吞吐方式，这此操作涉及整个渲染管线的多个环节，用来提高OpenGL的实现效率。常见的缓冲对象有：顶点缓冲对象(VBO)、像素缓冲对象(PBO)和帧缓冲对象(FBO)，各种缓冲对象的操作方式及应用场合不尽相同，但主要都是在关系到内存与显存之间需进行数据传输与交互时而进行的优化操作，因为内存与显存之间的数据交互在当前的硬件渲染架构下是必须的，但效率却又受
OpenGL学习脚印: 帧缓冲对象(Frame Buffer Object)
热门推荐
王定桥的专栏
09-03 1万+
写在前面 一直以来，我们在使用OpenGL渲染时，最终的目的地是默认的帧缓冲区，实际上OpenGL也允许我们创建自定义的帧缓冲区。使用自定义的帧缓冲区，可以实现镜面，离屏渲染，以及很酷的后处理效果。本节将学习帧缓存的使用，文中示例代码均可以在我的github下载。 本节内容整理自 1.OpenGL Frame Buffer Object (FBO) 2.www.learn
现代OpenGL函数指南：使用现代OpenGL函数的指南
02-04
现代OpenGL函数指南：使用现代OpenGL函数的指南
【OpenGL编程】Uniform缓冲对象（Uniform Buffer Object）
尹豆的博客
01-22 3784
Uniform缓冲对象（Uniform Buffer Object） 写在前面：最近在使用GLSL编程，还未掌握Uniform缓冲对象的相关知识，感觉处处碰壁，在这里对Uniform缓冲对象相关知识进行总结，同时本节案例是基于OpenGL ES 3.0实现的，案例程序均可在我github上下载。https://github.com/ModestBean/MySample
OpenGL 缓存对象(Buffer Object) 解析
snail_hunan的专栏
04-19 2285
缓存对象（Buffer Object）简介 OpenGL Buffer Object（缓存对象，简写BO），是OpenGL管理的一段内存，为了与我们CPU的内存区分开，一般叫OpenGL管理的内存，叫显存。 为了区分内存与显存，我这里从京东上搜索了内存条与显卡，如下图，这是一张显卡的截图，显卡使用的DDR为GDDR5，就是我们的显存，这个2G就表示这个显存的大小为2G。 再看内存，内存条，下面的内存条，使用的是DDR4，这里有2根，容量大小为8GB。 内存，是通过PCIE插槽，插在主板上的，也就是位于主
OpenGL.FrameBuffer Object
蛰伏--当你不够强大时，就不要放弃努力
12-11 541
帧缓冲区对象呢又称为FBO，它允许我们把渲染从窗口的帧缓冲区转移到我们所创建的一个或者多个离屏帧缓冲区。被推荐用于数据渲染到纹理对象，相对于其他同类技术，如数据拷贝或者交换缓冲区等等，使用FBO技术会更高效且易于实现。此buffer包含了color buffer,depth buffer,stencil buffer.渲染到纹理这个技术在游戏中经常用来模拟电视机或者监视器等等的效果。 1.FBO并不受窗口大小的限制。 2.纹理可以连接到FBO，允许直接渲染到纹理，不需要显示glCopyTexImage。 3
buffer object VAO VBO FBO TEXTURE OBJECT Frame Buffer 理解
Levi_Max的专栏
12-11 569
三个逆操作函数： gluUnProject glReadPixels glGetTexImage()三个函数代表了三种基本的数据类型，即 顶点属性数据、像素数据以及纹理对象数据。 BUFFER OBJECT缓冲区对象 glGenBuffers就是在显卡开辟一块内存，相当于new delete。这块开辟的内存可以存放特定类型的数据，也就变成了特定类型的buffer object（g
glMapBuffer
Frank的专栏
05-21 8158
glMapBufferglMapBuffer
OpenGL累积缓存的操作函数详细说明
josentop的专栏
10-11 2015
OpenGL中存在各种缓冲区,用以实现不同功能,(参考缓冲区简介) 。累积缓存(Accumulate Buffer)就是一种，它主要为了辅助累积计算。例如：运动模糊和全局反走样。对于累积缓存的操作，需要使用glAccum()等函数进行。下面是涉及到的主要函数：（一）void glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloa
OpenGL学习总结-数据缓存区（四）
最新发布
pplander的专栏
10-15 770
第二部分里介绍了缓冲区对象（Buffer Object）, 缓冲区对象是存储在 GPU 中的内存区域，用于存放顶点数据、索引数据、纹理数据等。OpenGL 使用缓冲区对象来高效管理和传输数据。作用：缓冲区对象通过在 GPU 上存储数据，提高了数据传输和渲染的效率。
GL_ARRAY_BUFFER是什么？
qq_43274123的博客
03-16 1667
OpenGL基础
【OpenGL ES】顶点缓冲区对象VBO与顶点数组对象VAO
Making Life Better. Making Others Better.
05-11 4811
【完整示例代码】https://github.com/geminy/aidear/tree/master/graphics/mu/examples/opengles3顶点属性即顶点数据，可以通过顶点数组逐顶点指定，也可以为所有顶点指定一个常量，所有OpenGL ES 3.0实现必须支持至少16个顶点属性，应用程序可以通过glGetIntegerv查询GL_MAX_VERTEX_ATTRIBS得到支持
OpenGL 高级数据、分批顶点属性与复制缓冲
baidu_41388533的博客
12-10 390
我们在OpenGL中大量使用缓冲来储存数据已经有很长时间了。操作缓冲其实还有更有意思的方式，而且使用纹理将大量数据传入着色器也有更有趣的方法。这一节中，我们将讨论一些更有意思的缓冲函数，以及我们该如何使用纹理对象来储存大量的数据（纹理的部分还没有完成）。
OpenGL帧缓冲：渲染缓冲区对象 Renderbuffer Objects
02-06 1234
OpenGL帧缓冲：渲染缓冲区对象 Renderbuffer Objects
OpenGL入门指南：基础概念与函数详解
OpenGL学习笔记是一份针对初学者的教程，主要介绍了OpenGL的基本概念和核心函数。OpenGL是一种图形渲染API，用于创建逼真的3D图形在计算机屏幕上显示。以下部分知识点概述： 1. **顶点连接与颜色处理**： - OpenGL...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值