C++ OpenGL 渲染两个具有不同颜色的矩形

我尝试创建两个具有两种不同颜色并朝相反方向移动的矩形对象。但是，我坚持用不同的颜色渲染两个矩形（目前它们是相同的颜色）。

有什么方法可以做到这一点？

这是代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include "ogldev_util.h"
#include "ogldev_math_3d.h"
GLuint VBO1;
GLuint VBO2;
GLuint gScaleLocation1;
GLuint gScaleLocation2;
const char* pVSFileName = "shader.vs";
const char* pFSFileName = "shader.fs";

static void RenderSceneCB()
{
    glClear(GL_COLOR_BUFFER_BIT);

    static float Scale1 = 0.0f;
    Scale1 += 0.01f;
    glUniform1f(gScaleLocation1, sinf(Scale1));
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, VBO1);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    static float Scale2 = 0.0f;
    Scale2 -= 0.01f;
    glUniform1f(gScaleLocation2, sinf(Scale2));
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, VBO2);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glDisableVertexAttribArray(0);
    glutSwapBuffers();
}

static void InitializeGlutCallbacks()
{
    glutDisplayFunc(RenderSceneCB);
    glutIdleFunc(RenderSceneCB);
}
static void CreateVertexBuffer()
{
    Vector3f Vertices[6];
    Vertices[0] = Vector3f(1.0f, -0.5f, 0.0f);
    Vertices[1] = Vector3f(1.0f, 0.5f, 0.0f);
    Vertices[2] = Vector3f(3.0f, -0.5f, 0.0f);
    Vertices[3] = Vector3f(1.0f, 0.5f, 0.0f);
    Vertices[4] = Vector3f(3.0f, 0.5f, 0.0f);
    Vertices[5] = Vector3f(3.0f, -0.5f, 0.0f);
    glGenBuffers(1, &VBO1);
    glBindBuffer(GL_ARRAY_BUFFER, VBO1);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
    Vector3f Vertices2[6];
    Vertices2[0] = Vector3f(-3.0f, -0.5f, 0.0f);
    Vertices2[1] = Vector3f(-3.0f, 0.5f, 0.0f);
    Vertices2[2] = Vector3f(-1.0f, -0.5f, 0.0f);
    Vertices2[3] = Vector3f(-3.0f, 0.5f, 0.0f);
    Vertices2[4] = Vector3f(-1.0f, 0.5f, 0.0f);
    Vertices2[5] = Vector3f(-1.0f, -0.5f, 0.0f);
    glGenBuffers(1, &VBO2);
    glBindBuffer(GL_ARRAY_BUFFER, VBO2);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices2), Vertices2, 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 %dn", 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 programn");
        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);
    gScaleLocation1 = glGetUniformLocation(ShaderProgram, "gScale");
    assert(gScaleLocation1 != 0xFFFFFFFF);
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(1024, 768);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Tutorial 05");
    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: %sn", glGetString(GL_VERSION));
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    CreateVertexBuffer();
    CompileShaders();
    glutMainLoop();
    return 0;
}

片段着色器

#version 330
out vec4 FragColor;
void main()
{
    FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}