Vertex Shader: Model-View-Projection Transform

Topic Overview

Four Coordinate Spaces

A 3D vertex starts in model space (local to the object). Before rendering, it passes through several spaces, each with a transformation matrix:

1. Model space: object-local coordinates, e.g. cube corners at (-1,-1,-1) to (1,1,1)
2. World space: model matrix M places the object in the scene
3. View space: view matrix V moves the camera to origin, looking down -Z
4. Clip space: projection matrix P maps the frustum to a canonical volume

The combined transform is v_clip = P * V * M * v_model. Column vectors apply right-to-left: M first, then V, then P.

Perspective Division to NDC

Clip space coordinates have a homogeneous w component. The GPU divides by w to reach normalized device coordinates in [-1, 1]. Projection matrices encode field of view, aspect ratio, and near/far planes. Distant objects appear smaller because w grows with depth.

glslCopy
Loading…

For example, a vertex at model-space (1, 0, 0) transformed by translation +45 on X lands at world (46, 0, 0) before view and projection compress it into clip space.

For This Exercise

You will implement 4x4 matrix-vector multiplication and the full MVP chain for a single vertex. This task requires you to print coordinates at each space. Getting multiplication order wrong (PVM vs MVP) is the most common bug on graphics forums, and this exercise forces you to trace the correct sequence.

Your Task

Implement the vertex shader's classic job: model → world → eye → clip → NDC → window. Build the model matrix from translate/scale/rotate calls, the view matrix from lookAt, and the projection from perspective or ortho, using exactly the OpenGL (gluPerspective/gluLookAt) conventions. Transform vertices through the chain, reject those outside the clip volume, and map the rest to the viewport.

Input

# starts a comment.

cCopy
Loading…

All matrices start as the identity.

Rules

• Model: each model call post-multiplies, M = M × T (like glTranslate), so the last call applies to the vertex first. The rotations are right-handed: roty 90 sends +x to -z, rotx turns +y toward +z, and rotz turns +x toward +y.
• lookAt: f = normalize(center - eye), s = normalize(f × up), u = s × f. The rows are s, u, -f, with translation (-s·eye, -u·eye, f·eye).
• perspective: f = 1/tan(fovy/2), and the matrix rows are:
  • [f/aspect 0 0 0]
  • [0 f 0 0]
  • [0 0 (far+near)/(near-far) 2·far·near/(near-far)]
  • [0 0 -1 0]
• ortho: the diagonal is 2/(r-l), 2/(t-b), -2/(f-n), and the translation is -(r+l)/(r-l), -(t+b)/(t-b), -(f+n)/(f-n).
• vertex: world = M·v, eye = V·world, clip = P·eye.
  • If w ≤ 0, print behind the camera (w <= 0): clipped.
  • Otherwise, print NDC = clip.xyz / w. If any |c| > w, print outside the view volume: followed by the failing axes ( x, y, z).
  • Otherwise, print window = ((x+1)/2·W, (y+1)/2·H, (z+1)/2).

You may use <math.h> (tan, sqrt, …): the task compiles with -lm.

Output

Numbers are printed with %.4f, except that a value with |x| < 0.00005 prints as 0.0000 (never -0.0000):

cCopy
Loading…

• show labels are model:, view:, projection: or mvp = projection * view * model:, followed by 4 indented rows.
• Errors:
  • model: translate X Y Z | scale X Y Z | rotx|roty|rotz DEG | reset
  • lookat: eye and center coincide, lookat: up is parallel to the view direction
  • perspective: 0 < FOVY < 180, ASPECT > 0, 0 < NEAR < FAR
  • ortho: planes must differ
  • viewport: W H > 0 (it resets to 800 600)
  • bad command: LINE
• Invalid commands leave the matrices unchanged.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Use column vectors (M × v) and keep the multiplication order explicit. Most bugs in this stage are order bugs.
2. Clip in clip space, before the divide: a point with w ≤ 0 would flip sign during the divide.

Hidden tests cover composed rotation and scale, lookAt, a wide-screen perspective, points behind the camera and beyond the near/far planes, an orthographic projection, and invalid parameters.