Author: Romain Vergne (website)
Please cite my name and add a link to my web page if you use this course

Image synthesis and OpenGL: graphics pipeline

Quick links to:

Reminder: simplified pipeline
Fixed pipeline (OpenGL 1)
Dynamic pipeline (OpenGL 2)
Dynamic pipeline (OpenGL 4)
Sources

Reminder: simplified pipeline


Download this simple scene

3D models : triangle soup (vertices and their attributes).
Lights: position, direction, color, intensity, etc.
Materials: shininess, translucency, textures, etc.
Camera: position, view, up, projection type, etc.
Rendering: resolution, post-effects, etc.

Rendering


Ray-tracing Propagate rays from pixels Scene = set of intersectable primitives	Rasterization Project primitives on screen discretize primitives Scene = set of rasterizable primitives

Graphic cards use rasterization!
Inputs: camera (MVP matrix), scene geometry (polygons), attributes (color, material,...), lights
Output: a raster image (Red,Green,Blue)

Rendering algorithm

clear destination buffers
configure scene properties (camera, light sources, etc)
load object geometry, textures and attributes
draw objects
display the rendered image (double buffering)
compute next image

The GPU

What is the difference between a CPU (Central Processing Unit) and a GPU (Graphics Processing Unit)? A simple demonstration here.

Allows complex computations by the graphic card (CPU free for other calculations)
Hundreds of operations in parallel
Access memory via specialized buffers (Vertex Buffers, Frame Buffers, Textures - in 1D / 2D / 3D)
Specialized pipeline for rendering rasterized images
Controllable via a graphics API (OpenGL / DirectX)
Programmable using specific programming languages (GLSL / HLSL / CG)

Fixed pipeline (OpenGL 1)

Vertex processing

Input: one vertex (and attributes)
Output: one vertex (modified)

Vertex projection

ModelView Matrix
Projection Matrix

Assign attributes

Color
Texture coordinates
etc.

Primitive processing

Input: vertices, topology
Output: primitive

Vertex assembly
Perspective division
Viewport transformation
Clipping
Backface culling

Rasterization

Input: primitive
Output: fragments

Fragment generation
Multiple possible fragment per pixel
Assign color / texture / depth / ... per fragment
Interpolation along each primitive

Fragment processing

Input: fragments
Output: pixel

Effects

Fog
Textures
Images

Tests

Stencil test
Depth test

Pixel processing

Input: pixels
Output: pixels

Alpha test
Blending

Fixed pipeline :

Choose an OpenGL state

Geometry
Light
Depth test
Blending
Culling
...

Apply this pipeline...
... and that's it!
Unable to make your own effects/lightings/etc

Dynamic pipeline (OpenGL 2)

Vertex and fragment processing now programmable!

Vertex shader
Fragment shader

little program executed on the GPU
languages:

GG (nvidia only)
HLSL (DirectX only - Microsoft)
GLSL (OpenGL Shading Language)

Why is it usefull?

How does a shader look like?

// GLSL version
#version 330

// Vertex attributes (given by glVertexAttribPointer(...))
layout(location = 0) in vec3 vertexPosition_modelspace;
layout(location = 1) in vec3 vertexColor;

// Output data: will be interpolated for each fragment
out vec3 fragmentColor;

// ModelViewProjection matrix (constant for the whole mesh)
uniform mat4 MVP;

void main() {
    // Output position of the vertex, in clip space : MVP * position
    gl_Position = MVP * vec4(vertexPosition_modelspace,1);

    // The color of each vertex will be interpolated
    // to produce the color of each fragment
    fragmentColor = vertexColor;
}

// GLSL version
#version 330

// Interpolated values from the vertex shaders
in vec3 fragmentColor;

// Ouput data
out vec3 color;

void main() {
    // Output color = color specified in the vertex shader,
    // interpolated between all 3 surrounding vertices
    color = fragmentColor;
}

Vertex shader

Fragment shader

How can we tell the GPU to use our own GLSL program?

Image taken here

Dynamic pipeline (OpenGL 4)

Programmable stages

Vertex/fragment shaders
Tesselation

Tess. Control Shader
Tess. Evaluation Shader
generate patches

Primitive

geometry shader
stream output

Compute

compute shader

Have a look to the full detailed pipeline here

Sources

PREVIOUS: EXERCICE02

NEXT: EXERCICE03