OpenGL编程逐步深入（十）索引绘制

最新推荐文章于 2023-02-25 19:58:58 发布

江荣波

最新推荐文章于 2023-02-25 19:58:58 发布

阅读量1.9k

点赞数

分类专栏： opengl 文章标签： opengl

opengl 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

准备知识

OpenGl提供了一些绘图函数。到目前为止我们使用的glDrawArrays绘图函数属于”顺序绘制”。这意味着顶点缓冲区从指定的偏移量开始被扫描，每X（点为1，直线为2等）个顶点构成一个图元。这样使用起来非常方便，缺点是当多个图元共用一个顶点时，这个顶点必须在顶点缓冲区中出现多次。也就是说，这些顶点没有共享的概念。属于”索引绘制”的函数则提供这种共享机制。我们除了一个顶点缓存区外，还有一个索引缓存区用来存放顶点的索引值。索引缓存区的扫描和顶点缓存区类似，以每X个索引对应的顶点构成一个基本图元。共享机制在提高内存使用效率上非常重要，因为计算机中的绝大多数图形对象都是三角形网格构成的，这些三角形有很多都是共用顶点。

我们来看一下顺序绘制：
这里写图片描述

如果是绘制三角形，GPU会将这些顶点分成以下几组：V0/1/2, V3/4/5, V6/7/8。

接下来看一下索引绘制：

这里写图片描述
这种情况下，GPU会使用这几组顶点来绘制三角形：V2/0/1, V5/2/4, V6/5/7。

使用索引绘制方式需要创建索引缓冲区，索引缓存区中的数据还要受到顶点缓冲区的限制，绘图调用的API函数也和之前不同。

项目配置

参见前面的教程。

程序代码

清单1.主程序代码tutorial10.cpp

/*

    Copyright 2010 Etay Meiri

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Tutorial 10 - Indexed draws
*/
#include "stdafx.h"
#include <string.h>
#include <assert.h>
#include <math.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include "ogldev_math_3d.h"
GLuint VBO;
GLuint IBO;
GLuint gWorldLocation;

const char* pVSFileName = "shader.vs";
const char* pFSFileName = "shader.fs";


static void RenderSceneCB()
{
    glClear(GL_COLOR_BUFFER_BIT);

    static float Scale = 0.0f;

    Scale += 0.01f;

    Matrix4f World;

    World.m[0][0] = cosf(Scale); World.m[0][1] = 0.0f; World.m[0][2] = -sinf(Scale); World.m[0][3] = 0.0f;
    World.m[1][0] = 0.0;         World.m[1][1] = 1.0f; World.m[1][2] = 0.0f        ; World.m[1][3] = 0.0f;
    World.m[2][0] = sinf(Scale); World.m[2][1] = 0.0f; World.m[2][2] = cosf(Scale) ; World.m[2][3] = 0.0f;
    World.m[3][0] = 0.0f;        World.m[3][1] = 0.0f; World.m[3][2] = 0.0f        ; World.m[3][3] = 1.0f;

    glUniformMatrix4fv(gWorldLocation, 1, GL_TRUE, &World.m[0][0]);

    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);

    glDrawElements(GL_TRIANGLES, 12, GL_UNSIGNED_INT, 0);

    glDisableVertexAttribArray(0);

    glutSwapBuffers();
}


static void InitializeGlutCallbacks()
{
    glutDisplayFunc(RenderSceneCB);
    glutIdleFunc(RenderSceneCB);
}

static void CreateVertexBuffer()
{
    Vector3f Vertices[4];
    Vertices[0] = Vector3f(-1.0f, -1.0f, 0.0f);
    Vertices[1] = Vector3f(0.0f, -1.0f, 1.0f);
    Vertices[2] = Vector3f(1.0f, -1.0f, 0.0f);
    Vertices[3] = Vector3f(0.0f, 1.0f, 0.0f);

    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
}

static void CreateIndexBuffer()
{
    unsigned int Indices[] = { 0, 3, 1,
        1, 3, 2,
        2, 3, 0,
        0, 1, 2 };

    glGenBuffers(1, &IBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices), Indices, GL_STATIC_DRAW);
}

static void AddShader(GLuint ShaderProgram, const char* pShaderText, GLenum ShaderType)
{
    GLuint ShaderObj = glCreateShader(ShaderType);

    if (ShaderObj == 0) {
        fprintf(stderr, "Error creating shader type %d\n", ShaderType);
        exit(1);
    }

    const GLchar* p[1];
    p[0] = pShaderText;
    GLint Lengths[1];
    Lengths[0]= strlen(pShaderText);
    glShaderSource(ShaderObj, 1, p, Lengths);
    glCompileShader(ShaderObj);
    GLint success;
    glGetShaderiv(ShaderObj, GL_COMPILE_STATUS, &success);
    if (!success) {
        GLchar InfoLog[1024];
        glGetShaderInfoLog(ShaderObj, 1024, NULL, InfoLog);
        fprintf(stderr, "Error compiling shader type %d: '%s'\n", ShaderType, InfoLog);
        exit(1);
    }

    glAttachShader(ShaderProgram, ShaderObj);
}

static void CompileShaders()
{
    GLuint ShaderProgram = glCreateProgram();

    if (ShaderProgram == 0) {
        fprintf(stderr, "Error creating shader program\n");
        exit(1);
    }

    string vs, fs;

    if (!ReadFile(pVSFileName, vs)) {
        exit(1);
    };

    if (!ReadFile(pFSFileName, fs)) {
        exit(1);
    };

    AddShader(ShaderProgram, vs.c_str(), GL_VERTEX_SHADER);
    AddShader(ShaderProgram, fs.c_str(), GL_FRAGMENT_SHADER);

    GLint Success = 0;
    GLchar ErrorLog[1024] = { 0 };

    glLinkProgram(ShaderProgram);
    glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
    if (Success == 0) {
        glGetProgramInfoLog(ShaderProgram, sizeof(ErrorLog), NULL, ErrorLog);
        fprintf(stderr, "Error linking shader program: '%s'\n", ErrorLog);
        exit(1);
    }

    glValidateProgram(ShaderProgram);
    glGetProgramiv(ShaderProgram, GL_VALIDATE_STATUS, &Success);
    if (!Success) {
        glGetProgramInfoLog(ShaderProgram, sizeof(ErrorLog), NULL, ErrorLog);
        fprintf(stderr, "Invalid shader program: '%s'\n", ErrorLog);
        exit(1);
    }

    glUseProgram(ShaderProgram);

    gWorldLocation = glGetUniformLocation(ShaderProgram, "gWorld");
    assert(gWorldLocation != 0xFFFFFFFF);
}
int _tmain(int argc, _TCHAR* argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(1024, 768);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Tutorial 10");

    InitializeGlutCallbacks();

    // Must be done after glut is initialized!
    GLenum res = glewInit();
    if (res != GLEW_OK) {
        fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
        return 1;
    }

    printf("GL version: %s\n", glGetString(GL_VERSION));

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    CreateVertexBuffer();
    CreateIndexBuffer();

    CompileShaders();

    glutMainLoop();

    return 0;
}

代码解读

GLuint IBO;

创建索引缓存句柄，对索引缓冲区的操作通过该句柄完成。

Vertices[0] = Vector3f(-1.0f, -1.0f, 0.0f);
Vertices[1] = Vector3f(0.0f, -1.0f, 1.0f);
Vertices[2] = Vector3f(1.0f, -1.0f, 0.0f);
Vertices[3] = Vector3f(0.0f, 1.0f, 0.0f);

为了演示顶点共享，我们需要更复杂的网格模型。很多教程都使用旋转立方体来演示这个知识点，这需要8个顶点和12个三角形。这里我们使用旋转四面体代替，它只需要4个顶点和4个三角形。

当我们从上面（即沿着Y轴）观看这些顶点时，顶点布局如下图所示：
这里写图片描述

unsigned int Indices[] = { 0, 3, 1,
                           1, 3, 2,
                           2, 3, 0,
                           0, 1, 2 };

索引缓冲区由一个索引数组组成，每个索引对应顶点缓冲区中的一个顶点。同时观察索引数组和上面的顶点分布图会发现最后一个三角形构成四面体的底面，另外三个三角形作为侧表面（这个例子中四面体并不是对称的）。

glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices), Indices, GL_STATIC_DRAW);

上面代码用于创建索引缓冲区并向其中填充数据，不同的是这里使用的参数是GL_ELEMENT_ARRAY_BUFFER，而创建顶点缓冲区使用的参数为GL_ARRAY_BUFFER。

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);

和顺序绘制方式一样，在绘制之前我们也要调用glBindBuffer，同时使用GL_ELEMENT_ARRAY_BUFFER作为参数。

glDrawElements(GL_TRIANGLES, 12, GL_UNSIGNED_INT, 0);

这里我们需要使用glDrawElements代替glDrawArrays。第一个参数指定要绘制的图元类型，第二个参数指定用来生成图元的索引数量，第三个参数是每个索引的数据类型，这里可供选择的有GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_UNSIGNED_INT。最后一个参数用来告诉GPU开始扫描索引缓冲区的偏移量，这里指定为0，表明从第一个索引开始。这个参数是非常有用的，因为有时候多个模型的顶点索引存放在同一个索引缓冲区。

运行效果

可以看到一个四面体在窗口中旋转。

这里写图片描述

江荣波

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
OpenGL编程逐步深入（十）索引绘制

OpenGl提供了一些绘图函数。到目前为止我们使用的glDrawArrays绘图函数属于”顺序绘制”。这意味着顶点缓冲区从指定的偏移量开始被扫描，每X（点为1，直线为2等）个顶点构成一个图元。这样使用起来非常方便，缺点是当多个图元共用一个顶点时，这个顶点必须在顶点缓冲区中出现多次。也就是说，这些顶点没有共享的概念。属于”索引绘制”的函数则提供这种共享机制。
复制链接

扫一扫