3D C/C++ tutorials -> Resources -> OpenGL perspective projection

Use for personal or educational purposes only. Commercial and other profit uses strictly prohibited. Exploitation of content on a website or in a publication prohibited.

To compile and run these tutorials some or all of these libraries are required: FreeImage 3.16.0, GLEW 1.11.0, GLUT 3.7.6 / GLUT for Dev-C++, GLM 0.9.5.4

mat4x4 M - model matrix - model-to-world space transformation, the result of several matrices multiplication (translation, rotation, scaling) may be stored in it
mat4x4 V - view matrix - world-to-view space transformation
mat4x4 P - perspective projection matrix - view-to-clip and clip-to-ndc space transformation (perspective division must be applied)
mat4x4 Bias - bias matrix - ndc-to-texture space transformation (shadow mapping, screen space ambient occlusion, ...)
mat4x4 Vp - viewport matrix - viewport transformation

vec4 v_m = vec4(x, y, z, 1) - vertex in model space

vec4 v_w = M * v_m - vertex in world space

vec4 v_v = V * v_w - vertex in view (camera, eye) space

V causes v_w to be rotated and translated in the opposite direction considering the rotation and position of the camera

if v_v.z < 0 then v_v is in front of the camera

vec4 v_c = P * v_v - vertex in clip space

v_c.x = P[0] * v_v.x
v_c.y = P[5] * v_v.y
v_c.z = P[10] * v_v.z + P[14] * v_v.w = P[10] * v_v.z + P[14]
v_c.w = P[11] * v_v.z = -v_v.z

v_c = P * V * M * v_m = (P * (V * (M * v_m))) - output of a vertex shader - gl_Position

For performance reasons the result of the model and view matrix multiplication is stored in the modelview matrix (GL_MODELVIEW_MATRIX, gl_ModelViewMatrix) MV = V * M; and the result of the modelview and projection matrix multiplication is stored in the modelviewprojection matrix (gl_ModelViewProjectionMatrix) MVP = P * MV = P * V * M;.

if v_c.w > 0 then v_c is in front of the camera

if (-v_c.w <= v_c.x < v_c.w) and (-v_c.w <= v_c.y < v_c.w) and (-v_c.w <= v_c.z < v_c.w) then v_c is inside the camera frustum and is visible on the screen

v_c.w != 1 therefore v_c must be divided by v_c.w

v_ndc = v_c / v_c.w - perspective division

if (-1 <= v_ndc.x < 1) and (-1 <= v_ndc.y < 1) and (-1 <= v_ndc.z < 1) then v_ndc is inside the camera frustum and is visible on the screen

vec4 v_t = Bias * v_ndc - vertex in texture space

v_t.x = v_ndc.x * 0.5 + 0.5
v_t.y = v_ndc.y * 0.5 + 0.5
v_t.z = v_ndc.z * 0.5 + 0.5

v_t.x and v_t.y are used to fetch the depth texture and v_t.z is used for depth comparison (shadow mapping, screen space ambient occlusion, ...)

if (0 <= v_t.x < 1) and (0 <= v_t.y < 1) and (0 <= v_t.z < 1) then v_t is inside the camera frustum

and if v_t lies in the

• near clip plane then v_t.z = 0
• far clip plane then v_t.z = 1

v_t.z is used for depth test and stored in the depth buffer

vec4 p = Vp * v_t - pixel on the screen

p.x = v_t.x * width + x
p.y = v_t.y * height + y

p.x and p.y are coordinates to the color and depth buffers

if a vertex v_t is inside the camera frustum then

x <= p.x < x + width
y <= p.y < y + height

See the Simple software renderer or Software shadow mapping tutorials for more details.


View matrix - gluLookAt(ex, ey, ez, cx, cy, cz, ux, uy, uz)

vec3 P_c = vec3(ex, ey, ez);

vec3 Z_c = normalize(P_c - vec3(cx, cy, cz));

vec3 Y_c = normalize(vec3(ux, uy, uz));

vec3 X_c = normalize(cross(Y_c, Z_c));

Y_c = cross(Z_c, X_c);



Perspective projection matrix - gluPerspective(fovy, aspect, n, f)



Bias matrix



Viewport matrix - glViewport(x, y, width, height)