Lab 03 - Shaders

Task 1 - Switch Back to Core Profile

Open src/main.cpp and revert the profile hint you changed in the First Triangle lab (Lab 02). Core Profile is required from this lab onward.

1. Find the line: glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
2. Change it back to GLFW_OPENGL_CORE_PROFILE as shown below.

// file: src/main.cpp -- update the profile hint
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

If you run the project now, the window will open but the triangle will disappear. That is expected: Core Profile demands a shader program, and none is bound yet.

Task 2 - Create the Shader File

In the project root, create a new text file at res/shaders/triangle.shader. Copy the content below exactly. The #shader vertex and #shader fragment lines are custom markers read by the C++ parser you will write in Task 3. They are never passed to the GLSL compiler.

The fragment shader outputs a flat blue colour defined by the vec4 constructor: red 0.2, green 0.6, blue 1.0, alpha 1.0. Change these values to any colour you prefer.

#shader vertex
#version 430 core
layout (location = 0) in vec3 aPos;
void main() {
    gl_Position = vec4(aPos, 1.0);
}

#shader fragment
#version 430 core
out vec4 FragColour;
void main() {
    FragColour = vec4(0.2, 0.6, 1.0, 1.0);
}

Task 3 - Write the Shader File Parser

Add the includes and the parseShader function to src/main.cpp, above main(). The function reads the .shader file line by line and routes each line to either the vertex or fragment string depending on which #shader marker was seen most recently.

1. Add #include <fstream> and #include <sstream> at the top of the file.
2. Copy the struct and function signature below, then implement the loop body marked with // TODO.

// file: src/main.cpp -- add above main()
#include <fstream>
#include <sstream>

struct ShaderSource {
    std::string vertex;
    std::string fragment;
};

ShaderSource parseShader(const std::string& filepath) {
    std::ifstream file(filepath);
    std::stringstream ss[2];
    int type = -1;
    std::string line;
    while (std::getline(file, line)) {
        // TODO: if line contains "#shader vertex", set type = 0
        // TODO: if line contains "#shader fragment", set type = 1
        // TODO: otherwise if type is 0 or 1, write line + '\n' to ss[type]
    }
    return { ss[0].str(), ss[1].str() };
}

Hint: use line.find("#shader vertex") != std::string::npos to test whether the marker appears anywhere in the current line.

Task 4 - Add the Shader Compiler with Error Checking

Copy the function below into src/main.cpp, above main() and after the parser. It compiles one shader stage and prints any GLSL error message the driver reports. The function is provided in full because the error-checking API is boilerplate you will reuse unchanged in every project.

// file: src/main.cpp -- provided for reference, add above main()
static unsigned int compileShader(unsigned int type, const std::string& source) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (!result) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = new char[length];
        glGetShaderInfoLog(id, length, &length, message);
        std::cerr << "Shader compile error: " << message << '\n';
        delete[] message;
        return 0;
    }
    return id;
}

To test the error reporting, try introducing a deliberate typo in the fragment shader (for example, remove the semicolon after FragColour = ...), run the project, and read the console output. Fix the typo before continuing.

Task 5 - Write the Program Linker

Add the createProgram function below the compiler. It takes the two GLSL source strings, compiles each stage, attaches them to a program object, links the program, then deletes the now-redundant shader objects.

1. Create a program object with glCreateProgram().
2. Compile the vertex shader: compileShader(GL_VERTEX_SHADER, vertSrc).
3. Compile the fragment shader: compileShader(GL_FRAGMENT_SHADER, fragSrc).
4. Attach both to the program with glAttachShader.
5. Link with glLinkProgram.
6. Delete both shader objects with glDeleteShader (the linked program retains its own copy of the compiled code).
7. Return the program ID.

// file: src/main.cpp -- add above main(), after compileShader
static unsigned int createProgram(const std::string& vertSrc, const std::string& fragSrc) {
    // TODO: create a program with glCreateProgram
    // TODO: compile vertex shader using compileShader(GL_VERTEX_SHADER, vertSrc)
    // TODO: compile fragment shader using compileShader(GL_FRAGMENT_SHADER, fragSrc)
    // TODO: attach both shaders to the program with glAttachShader
    // TODO: call glLinkProgram
    // TODO: delete both shader objects with glDeleteShader
    // TODO: return the program ID
}

Task 6 - Load and Use the Shader Program

Wire everything together in main(). Call the parser and linker after the VAO and VBO setup, then activate the program each frame before drawing.

1. After the VAO and VBO setup code (and before the render loop), parse the shader file and create the program:

// file: src/main.cpp -- add after VAO/VBO setup, before the render loop
ShaderSource src = parseShader("res/shaders/triangle.shader");
unsigned int shader = createProgram(src.vertex, src.fragment);

2. Inside the render loop, add glUseProgram(shader) before glBindVertexArray and glDrawArrays:

// TODO: call glUseProgram(shader)
// TODO: call glBindVertexArray(vao)  -- already present from Lab 02
// TODO: call glDrawArrays(GL_TRIANGLES, 0, 3)  -- already present from Lab 02

3. In the cleanup section after the render loop, add glDeleteProgram(shader) alongside the existing glDeleteVertexArrays and glDeleteBuffers calls.