Lab 05 - Index Buffers and Uniforms [SOLUTION]

Task 1 - Add a Uniform to the Shader

Open res/shaders/triangle.shader and update the fragment section so the colour comes from a uniform rather than a hard-coded constant. The vertex section does not change.

1. Add the line uniform vec4 uColour; before the out vec4 FragColour; declaration.
2. Replace the hard-coded vec4(0.2, 0.6, 1.0, 1.0) assignment with uColour.

#shader fragment
#version 430 core
// TODO: declare uniform vec4 uColour here
out vec4 FragColour;
void main() {
    // TODO: assign uColour to FragColour instead of the hard-coded colour
}

Task 2 - Reduce to 4 Unique Vertices

Replace the 6-entry vertex array in src/main.cpp with the 4-entry array below. Remove the duplicate entries that were needed by glDrawArrays. The index array (Task 3) will tell the GPU which positions to use and in what order.

// file: src/main.cpp -- replace the existing vertices[] array
float vertices[] = {
    -0.5f, -0.5f, 0.0f,   // 0: bottom-left
     0.5f, -0.5f, 0.0f,   // 1: bottom-right
     0.5f,  0.5f, 0.0f,   // 2: top-right
    -0.5f,  0.5f, 0.0f    // 3: top-left
};

Task 3 - Define the Index Array

Add the index array immediately after the vertex array. Each row defines one triangle by listing three vertex slot numbers. The positions themselves are not repeated - only the slot references are.

// file: src/main.cpp -- add after vertices[]
unsigned int indices[] = {
    0, 1, 2,   // triangle 1: bottom-left -> bottom-right -> top-right
    2, 3, 0    // triangle 2: top-right -> top-left -> bottom-left
};

Task 4 - Create and Upload the IBO

Add the IBO setup after the glVertexAttribPointer and glEnableVertexAttribArray calls, while the VAO is still bound. The VAO stores the element buffer binding as part of its state.

1. Declare unsigned int ibo.
2. Call glGenBuffers(1, &ibo).
3. Call glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo).
4. Call glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW).
5. Now unbind the VAO with glBindVertexArray(0).

// file: src/main.cpp -- add after glEnableVertexAttribArray, while VAO is still bound
// TODO: declare unsigned int ibo
// TODO: generate one buffer and store in ibo
// TODO: bind as GL_ELEMENT_ARRAY_BUFFER
// TODO: upload sizeof(indices) bytes with GL_STATIC_DRAW

glBindVertexArray(0);  // unbind VAO after the IBO is bound, not before

Also add glDeleteBuffers(1, &ibo) to the cleanup section after the render loop, alongside the existing VBO cleanup.

Task 5 - Switch to glDrawElements

Inside the render loop, replace the glDrawArrays call. The new call reads 6 indices from the bound IBO and uses them to assemble two triangles from the 4 positions in the VBO.

1. Remove: glDrawArrays(GL_TRIANGLES, 0, 6);
2. Add the call below.

// TODO: replace glDrawArrays with glDrawElements
//       primitive: GL_TRIANGLES
//       count: 6  (number of indices, not vertices)
//       type: GL_UNSIGNED_INT
//       offset: (void*)0

Task 6 - Set the Uniform Value from C++

Wire the C++ side of the uniform. The location is queried once after the program is created and cached for reuse. The value is written each frame after the program is activated.

1. After the createProgram call and before the render loop, retrieve and store the uniform location:

// file: src/main.cpp -- add after createProgram, before the render loop
// TODO: call glGetUniformLocation(shader, "uColour") and store the result in int colourLoc
//       if colourLoc is -1, the name was not found - check the spelling matches the shader exactly

2. Inside the render loop, after glUseProgram(shader) and before the draw call, set the colour:

// TODO: call glUniform4f(colourLoc, r, g, b, a) with a colour of your choice
//       glUniform4f takes four floats in the range 0.0 to 1.0 (red, green, blue, alpha)