C 使用顶点缓冲区对象在OpenGL中绘制基本线

我遵循了一些，我的代码可以编译，但它不能正常工作

我希望看到一个白色的矩形，但是除了清晰的颜色之外，没有任何东西被渲染。调用

glDrawArrays

后，

glGetError

告诉我已引发错误1282。我确信问题很明显，但我看不出我错在哪里。下面是我的简单问题示例：

#include <errno.h>
#include <stdio.h>

#include <GLFW/glfw3.h>
#include <GL/gl.h>

#define WINDOW_W 300
#define WINDOW_H 300

static const GLchar *vertex_shader_src = {
    "#version 440\n"
    "in vec4 position;\n"
    "uniform mat4 projection;\n"
    "void main()\n"
    "{\n"
        "\tgl_Position = projection * position;\n"
    "}\n"
};

static const GLchar *fragment_shader_src = {
    "#version 440\n"
    "uniform vec4 color;\n"
    "out vec4 outputColor;\n"
    "void main()\n"
    "{\n"
        "outputColor = color;\n"
    "}\n"
};

static GLuint program = 0;

static GLuint vao = 0;

static const GLfloat rect_vertices[] = {
    5.0f, 5.0f,
    WINDOW_W - 5.0f, 5.0f,

    WINDOW_W - 5.0f, 5.0f,
    WINDOW_W - 5.0f, WINDOW_H - 5.0f,

    WINDOW_W - 5.0f, WINDOW_H - 5.0f,
    5.0f, WINDOW_H - 5.0f,

    5.0f, WINDOW_H - 5.0f,
    5.0f, 5.0f
};

static GLuint rect_vbo = 0;

int init_program()
{
    GLint status;
    GLuint vertexShader;
    GLuint fragmentShader;

    // Initialize our vertex shader.

    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertex_shader_src, NULL);
    glCompileShader(vertexShader);

    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);

    if(status == GL_FALSE)
        return -EINVAL;

    // Initialize our fragment shader.

    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragment_shader_src, NULL);
    glCompileShader(fragmentShader);

    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);

    if(status == GL_FALSE)
        return -EINVAL;

    // Initialize the program.

    program = glCreateProgram();

    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);

    glLinkProgram(program);

    glGetProgramiv(program, GL_LINK_STATUS, &status);

    if(status == GL_FALSE)
        return -EINVAL;

    // Detach the shaders, now that the program is linked.

    glDetachShader(program, vertexShader);
    glDetachShader(program, fragmentShader);

    // Done!

    return 0;
}

void ortho_matrix(GLfloat *m, GLfloat l, GLfloat r,
    GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
    m[0] = 2.0f / (r - l);
    m[1] = 0.0f;
    m[2] = 0.0f;
    m[3] = 0.0f;

    m[4] = 0.0f;
    m[5] = 2.0f / (t - b);
    m[6] = 0.0f;
    m[7] = 0.0f;

    m[8] = 0.0f;
    m[9] = 0.0f;
    m[10] = -2.0f / (f - n);
    m[11] = 0.0f;

    m[12] = 0.0f;
    m[13] = 0.0f;
    m[14] = 0.0f;
    m[15] = 1.0f;
}

int gl_color(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
{
    GLint colorVec;
    GLfloat color[4] = {r, g, b, a};

    colorVec = glGetUniformLocation(program, "color");

    if(colorVec == -1)
        return -EINVAL;

    glUniform4fv(colorVec, 1, color);

    return 0;
}

int set_uniforms(int width, int height)
{
    int r;
    GLint orthoMatrix;
    GLfloat matrix[16];

    // Set our orthographic projection uniform.

    orthoMatrix = glGetUniformLocation(program, "projection");

    if(orthoMatrix == -1)
        return -EINVAL;

    ortho_matrix(matrix, -0.5f, ((GLfloat) (width - 1)) + 0.5f,
        ((GLfloat) (height - 1)) + 0.5f, -0.5f, 0.0f, 1.0f);

    glUniformMatrix4fv(orthoMatrix, 1, GL_FALSE, matrix);

    // Set our rendering color uniform.

    r = gl_color(1.0f, 1.0f, 1.0f, 1.0f);

    if(r < 0)
        return r;

    // Done!

    return 0;
}

int init_vbo()
{
    glGenBuffers(1, &rect_vbo);

    glBindBuffer(GL_ARRAY_BUFFER, rect_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(rect_vertices),
        rect_vertices, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    return 0;
}

int render()
{
    GLenum err;

    glBindBuffer(GL_ARRAY_BUFFER, rect_vbo);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);

    glDrawArrays(GL_LINES, 0, sizeof(rect_vertices) / sizeof(GLfloat));

err = glGetError();

while(err != GL_NO_ERROR)
{
    printf("glDrawArrays err: %d\n", err);
    err = glGetError();
}

    glDisableVertexAttribArray(0);

    return 0;
}

int main(void)
{
    int r;
    GLFWwindow *window;

    int width;
    int height;

    if(!glfwInit())
        return -EINVAL;

    window = glfwCreateWindow(WINDOW_W, WINDOW_H,
        "My Window", NULL, NULL);

    if(!window)
    {
        glfwTerminate();
        return 1;
    }

    glfwMakeContextCurrent(window);

    r = init_program();

    if(r < 0)
    {
        glfwTerminate();
        return 1;
    }

    r = init_vbo();

    if(r < 0)
    {
        glfwTerminate();
        return 1;
    }

    while(!glfwWindowShouldClose(window))
    {
        // Initialize the GL viewport.

        glfwGetFramebufferSize(window, &width, &height);

        r = set_uniforms(width, height);

        if(r < 0)
        {
            glfwTerminate();
            return r;
        }

        glViewport(0, 0, width, height);

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glUseProgram(program);

        // Call the user-provided rendering function.

        r = render();

        if(r < 0)
        {
            glfwTerminate();
            return r;
        }

        // End GL rendering, swap the buffer, and poll for events.

        glUseProgram(0);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();

    return 0;
}

#包括
#包括
#包括
#包括
#定义窗口\u W 300
#定义窗口\u H 300
静态常量GLchar*顶点\u着色器\u src={
“#版本440\n”
“处于vec4位置；\n”
“一致mat4投影；\n”
“void main（）\n”
“{\n”
“\tgl\u位置=投影*位置；\n”
“}\n”
};
静态常量GLchar*片段\u着色器\u src={
“#版本440\n”
“统一的vec4颜色；\n”
“out vec4 outputColor；\n”
“void main（）\n”
“{\n”
“outputColor=color；\n”
“}\n”
};
静态GLuint程序=0；
静态胶合vao=0；
静态常量GLfloat rect_顶点[]={
5.0f，5.0f，
窗户W-5.0楼，5.0楼，
窗户W-5.0楼，5.0楼，
窗户W-5.0f，窗户H-5.0f，
窗户W-5.0f，窗户H-5.0f，
5.0楼，窗高-5.0楼，
5.0楼，窗高-5.0楼，
5.0f，5.0f
};
静态GLuint rect_vbo=0；
int init_程序（）
{
闪烁状态；
GLuint顶点着色器；
胶合碎片；
//初始化顶点着色器。
vertexShader=glCreateShader（GL_VERTEX_SHADER）；
glShaderSource（vertexShader，1和vertex_shader_src，NULL）；
glCompileShader（顶点着色器）；
glGetShaderiv（顶点着色器、GL编译状态和状态）；
如果（状态==GL\U FALSE）
返回-艾因瓦尔；
//初始化片段着色器。
fragmentShader=glCreateShader（GL_FRAGMENT_SHADER）；
glShaderSource（fragmentShader，1和fragment_shader_src，NULL）；
glCompileShader（fragmentShader）；
glGetShaderiv（碎片着色器、GL\u编译状态和状态）；
如果（状态==GL\U FALSE）
返回-艾因瓦尔；
//初始化程序。
program=glCreateProgram（）；
glAttachShader（程序，顶点着色器）；
glAttachShader（程序、碎片着色器）；
glLinkProgram（program）；
glGetProgramiv（程序、GL链接状态和状态）；
如果（状态==GL\U FALSE）
返回-艾因瓦尔；
//分离着色器，现在程序已链接。
glDetachShader（程序、顶点着色器）；
glDetachShader（程序、碎片着色器）；
//完成了！
返回0；
}
空心正交矩阵（GLfloat*m、GLfloat l、GLfloat r、，
GLfloat b、GLfloat t、GLfloat n、GLfloat f）
{
m[0]=2.0f/（r-l）；
m[1]=0.0f；
m[2]=0.0f；
m[3]=0.0f；
m[4]=0.0f；
m[5]=2.0f/（t-b）；
m[6]=0.0f；
m[7]=0.0f；
m[8]=0.0f；
m[9]=0.0f；
m[10]=-2.0f/（f-n）；
m[11]=0.0f；
m[12]=0.0f；
m[13]=0.0f；
m[14]=0.0f；
m[15]=1.0f；
}
内部GLU颜色（GLfloat r、GLfloat g、GLfloat b、GLfloat a）
{
闪烁色向量；
GLfloat color[4]={r，g，b，a}；
colorVec=glGetUniformLocation（程序，“颜色”）；
如果（colorVec==-1）
返回-艾因瓦尔；
glUniform4fv（colorVec，1，color）；
返回0；
}
int set_制服（int宽度、int高度）
{
INTR；
闪烁正交矩阵；
GLfloat矩阵[16]；
//将正交投影设置为一致。
正交矩阵=glGetUniformLocation（程序，“投影”）；
if（正交矩阵==-1）
返回-艾因瓦尔；
正交矩阵（矩阵，-0.5f，（（GLfloat）（宽度-1））+0.5f，
（（GLfloat）（高度-1））+0.5f、-0.5f、0.0f、1.0f）；
glUniformMatrix4fv（正交矩阵，1，GL_假，矩阵）；
//将渲染颜色设置为均匀。
r=gl_颜色（1.0f、1.0f、1.0f、1.0f）；
if（r<0）
返回r；
//完成了！
返回0；
}
int init_vbo（）
{
glGenBuffers（1，&rectvbo）；
glBindBuffer（GL_数组_BUFFER，rect_vbo）；
glBufferData（GL_数组_缓冲区，sizeof（rect_顶点），
矩形顶点，GL静态绘制）；
glBindBuffer（GL_数组_BUFFER，0）；
返回0；
}
int render（）
{
肩胛盂；
glBindBuffer（GL_数组_BUFFER，rect_vbo）；
GlenableVertexAttributeArray（0）；
glvertexattributepointer（0,2，GL_FLOAT，GL_FALSE，0,0）；
gldrawArray（GL_线，0，sizeof（rect_顶点）/sizeof（GLfloat））；
err=glGetError（）；
while（err！=GL\u无错误）
{
printf（“glDrawArrays错误：%d\n”，错误）；
err=glGetError（）；
}
glDisableVertexAttributeArray（0）；
返回0；
}
内部主（空）
{
INTR；
GLFWwindow*窗口；
整数宽度；
内部高度；
如果（！glfwInit（））
返回-艾因瓦尔；
窗口=glfwCreateWindow（窗口W、窗口H、，
“我的窗口”，空，空）；
如果（！窗口）
{
glfwTerminate（）；
返回1；
}
glfwMakeContextCurrent（窗口）；
r=init_程序（）；
if（r<0）
{
glfwTerminate（）；
返回1；
}
r=init_vbo（）；
if（r<0）
{
glfwTerminate（）；
返回1；
}
而（！glfwWindowShouldClose（窗口））
{
//初始化GL视口。
glfwGetFramebufferSize（窗口、宽度和高度）；
r=套装制服（宽度、高度）；
if（r<0）
{
glfwTerminate（）；
返回r；
}
glViewport（0，0，宽度，高度）；
glClearColor（0.0f、0.0f、0.0f、1.0f）；
glClear（GLU颜色缓冲位）；
glUseProgram（程序）；
//调用用户提供的呈现函数。
r=render（）；
if（r<0）
{
glfwTerminate（）；
返回r；
}
//结束GL渲染、交换缓冲区并轮询事件。
glUseProgram（0）；
glfwSwapBuffers（窗口）；
glfwPollEvents（）；
}
glfwTerminate（）；
返回0；
}

我试着搜索这个错误号，我发现了，例如，但我真的看不到任何方法来找出具体的错误

---

我做错了什么，或者，我如何才能发现呢？

我实际上发现了什么是错的。这个错误实际上发生了很多次

glDrawArrays(GL_LINES, 0, sizeof(rect_vertices) / sizeof(GLfloat));

glDrawArrays(GL_LINES, 0, sizeof(rect_vertices) / (2 * sizeof(GLfloat)));