Simulate the OpenGL Triangle Pipeline

Topic Overview

OpenGL's Programmable Pipeline

OpenGL is a cross-platform API for 2D and 3D graphics. Despite being over 30 years old, its pipeline stages remain relevant because Vulkan, D3D12, and Metal expose the same flow with lower-level control.

The programmable pipeline stages:

1. Vertex Specification: upload vertex data via VBOs; optional EBO for indexed drawing
2. Vertex Shader: transform positions to clip space, pass varyings forward
3. Primitive Assembly: group vertices into triangles (every 3 vertices = 1 triangle)
4. Rasterization: convert triangles to fragments, interpolate attributes
5. Fragment Shader: per-fragment color, texture sampling, lighting
6. Per-Sample Operations: depth test, blending, framebuffer writes

Stateful Binding Before Draw

OpenGL is stateful: you bind buffers, shaders, textures, and uniforms, then call glDrawElements. For example, a single triangle draw might bind a VAO, set the MVP uniform, activate a texture unit, and issue one draw call producing thousands of fragments from three vertices.

cCopy
Loading…

Modern APIs replace implicit global state with explicit pipeline state objects, but the stage sequence is identical. Debugging "why is my triangle invisible" almost always traces back to one of these stages.

For This Exercise

You will simulate the OpenGL pipeline for a single colored triangle, printing what happens at each stage. This task asks you to trace vertex transformation, attribute interpolation, and final fragment color. Understanding this pipeline is the prerequisite for every Vulkan exercise in this subtrack.

Your Task

Simulate the part of an OpenGL driver that turns API calls into vertices:

• buffer objects and the GL_ARRAY_BUFFER binding point;
• glVertexAttribPointer capturing the currently bound buffer;
• enabling attribute arrays;
• vertex fetch in glDrawArrays, which reads each attribute from an interleaved buffer with a byte stride and offset;
• OpenGL's error model: an error flag that keeps the first error until glGetError reads it.

Input

One call per line (// starts a comment):

cCopy
Loading…

Rules

• Names: glGenBuffers returns the next unused names, starting at 1 (at most 15 in total). A negative N gives GL_INVALID_VALUE and prints glGenBuffers: n must be >= 0.
• glBindBuffer:
  • a target other than GL_ARRAY_BUFFER gives GL_INVALID_ENUM;
  • an ID that was not generated gives GL_INVALID_OPERATION;
  • 0 unbinds.
• glBufferData: with nothing bound, it gives GL_INVALID_OPERATION.
• glVertexAttribPointer:
  • index outside 0-7, size outside 1-4, or a negative stride/offset gives GL_INVALID_VALUE;
  • a stride or offset that is not a multiple of 4 gives GL_INVALID_OPERATION;
  • with no buffer bound, it gives GL_INVALID_OPERATION;
  • otherwise it records size, stride, offset and the bound buffer. Rebinding later does not change the attribute.
• Errors keep the old state: a call that raises an error changes nothing.
• glDrawArrays:
  • an unknown mode gives GL_INVALID_ENUM, and a negative first/count gives GL_INVALID_VALUE;
  • with no enabled attribute, it prints glDrawArrays: no enabled attributes;
  • fetch: vertex v of attribute a starts at byte offset + v × stride, where a stride of 0 means tightly packed (size × 4). If the last vertex's attribute ends past the buffer, print glDrawArrays: attribute A reads past the end of buffer B (needs N bytes, has M) for each such attribute, set GL_INVALID_OPERATION, and draw nothing.
• glGetError prints and clears the pending error: GL_NO_ERROR, GL_INVALID_ENUM, GL_INVALID_VALUE or GL_INVALID_OPERATION. Only the first error since the last read is kept.

Output

cCopy
Loading…

• Draw header: vert(ex|ices), then the number of whole primitives (count / 3, / 2 or / 1) with a singular or plural noun.
• Vertex lines: each vertex lists its enabled attributes in index order, with values printed by %g.
• Other errors: malformed calls print a usage line (glBindBuffer: TARGET ID, glVertexAttribPointer: INDEX SIZE STRIDE OFFSET, …), and unknown calls print unknown call X.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Keep per-attribute state separate from the global binding. Capturing the buffer at glVertexAttribPointer time is how VAOs work.
2. Bounds-check every fetch before drawing. That is what robust-buffer-access drivers guarantee.

Hidden tests cover two buffers feeding two attributes, a drawing range with FIRST > 0, reads past the end, invalid enums and values, the sticky first error, misaligned offsets, a pointer call with no buffer bound, and a draw with no enabled attributes.