Pipeline

CS332 Computer Graphics
Lecture 3
Graphics Pipeline
Graphics Pipeline
Primitives: Points, Lines, Triangles
[Angel Ch. 2]
Abdullah Alfarrarjeh
German Jordanian University
1
Graphics Pipeline
Primitives+ Translate Is it visible 3D to 2D Convert to Shown

material Rotate on screen? pixels on the screen
properties Scale (framebuffer)
2
The Framebuffer
• Special memory on the graphics card
• Stores the current pixels to be displayed on the

monitor
• Monitor has no storage capabilities
• The framebuffer is copied to the monitor at each

refresh cycle
A framebuffer is designed with enough memory to store two frames worth of video data.
In a technique known generally as double buffering, the framebuffer uses half of its
memory to display the current frame. While that memory is being displayed, the other 3
half of memory is filled with data for the next frame.
Rendering with OpenGL
• Application generates the

geometric primitives (polygons, lines)
• System draws each one into the framebuffer
• Entire scene is redrawn anew every frame
4
The pipeline is implemented by
OpenGL, graphics driver and
the graphics hardware
OpenGL programmer does not need to implement

the pipeline.
However, pipeline is reconfigurable

➔ “shaders”
5
Graphics Pipeline
•Efficiently implementable in hardware

(but not in software)
•Each stage can employ multiple specialized processors,

working in parallel, buses between stages
•#processors per stage, bus bandwidths are fully

tuned for typical graphics use
6
Vertices (compatibility profile)
• Vertices in world coordinates

void glVertex3f(GLfloat x, GLfloat y, GLfloat z)
– Vertex (x, y, z) is sent down the pipeline.
– Function call then returns.
• Use GLtype for portability and consistency
• glVertex{234}{sfid}[v](TYPE coords)
Number of Data Type Vector
Components s – short Omit “v” for
2 – (x, y) f – float scalar form:
3 – (x, y, z) I - integer glVertex2f(x, y) 7
4 – (x, y, z, w) d - double
Vertices (core profile)
• Vertices in world coordinates

• Store vertices into a Vertex Buffer Object (VBO)
• Upload the VBO to the GPU during program
initialization (before rendering)
• OpenGL renders directly from the VBO
8
Transformer (compatibility profile)
• Transformer in world coordinates

• Must be set before object is drawn!
glRotatef(45.0, 0.0, 0.0, -1.0);
glVertex2f(1.0, 0.0);
• Complex [Angel Ch. 3]
9
Transformer (core profile)
• Transformer in world coordinates

• 4x4 matrix
• Created manually by the user
• Transmitted to the shader program before rendering
10
Clipper
• Mostly automatic (must set viewing volume)
11
Projector
• Complex transformation [Angel Ch. 4]

Orthographic Perspective
12
Projector
• Complex transformation [Angel Ch. 4]

Orthographic Perspective
• In the perspective view (the default), objects which are far away are smaller than
13
those nearby.
• In the orthographic view, all objects appear at the same scale.
Rasterizer
• Interesting algorithms [Angel Ch. 6]

• To window coordinates
• Antialiasing
14
Geometric Primitives
• Suppose we have 8 vertices:
p0, p1, p2, p3, p4, p5, p6, p7
• Then, one can interpret them as:
• GL_POINTS, GL_LINES, GL_TRIANGLES

are examples of primitive type
15
(compatibility profile)
• Specified via vertices
• General schema
glBegin(type);
glVertex3f(x1, y1, z1);
...
glVertex3f(xN, yN, zN);
glEnd();
• type determines interpretation of vertices
• Can use glVertex2f(x,y) in 2D
16
Example: Draw Two Square Edges
(0,1) (1,1)
• Type = GL_LINES
glBegin(GL_LINES);
glVertex3f(0.0, 0.0, -1.0);
glVertex3f(1.0, 0.0, -1.0);
glVertex3f(1.0, 1.0, -1.0);
(0,0) (1,0)
glVertex3f(0.0, 1.0, -1.0);
glEnd();
• Calls to other functions are allowed between
glBegin(type) and glEnd();
17
(core profile)
• Specified via vertices
• Stored in a Vertex Buffer Object
(VBO)
int numVertices = 300;
float vertices[3 * numVertices];
// (… fill the “vertices” array …)

// create the VBO:
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices),
18
vertices, GL_STATIC_DRAW);
Render Points and Line Segments
glBegin (GL_POINTS); // or GL_LINES to render lines

glVertex3f(…);
…
glVertex3f(…);
glEnd();
19
Render Points and Line Segments
(core profile)
glDrawArrays(GL_POINTS, 0, numVertices); // render points

glDrawArrays(GL_LINES, 0, numVertices); // render lines
20
Main difference between the two profiles
Compatibility: Core:
Initialization:
float vertices[3 * numVertices];
Rendering: // (… fill the “vertices” array …)
glBegin(type); // create the VBO:

glVertex3f(x1, y1, z1); GLuint vbo;
... glGenBuffers(1, &vbo);

glVertex3f(xN, yN, zN); glBindBuffer(GL_ARRAY_BUFFER, vbo);
glEnd(); glBufferData(GL_ARRAY_BUFFER,
sizeof(vertices), vertices, GL_STATIC_DRAW);
Rendering:
glDrawArrays(type, 0, numVertices);
22
Common Bug

float * vertices = (float*) malloc (sizeof(float) * 3 * numVertices);
…
glBufferData(GL_ARRAY_BUFFER,
What is wrong?
23
Common Bug
float * vertices = (float*) malloc (sizeof(float) * 3 * numVertices);
…
sizeof(float) * 3 * numVertices, vertices, GL_STATIC_DRAW);
24
Polygons
• Polygons enclose an area
• Rendering of area (fill) depends on attributes

• All vertices must be in one plane in 3D
• GL_POLYGON and GL_QUADS are only
available in the compatibility profile
(removed in core profile since OpenGL 3.1)
25
Triangle Strips
• Efficiency in space and time

• Reduces visual artefacts on old graphics cards
26
Summary
1. Graphics pipeline
2. Primitives: vertices, lines, triangles
27

Pipeline

Uploaded by

Copyright:

Available Formats

Pipeline

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pipeline

Uploaded by

Copyright:

Available Formats

CS332 Computer Graphics

Primitives+ Translate Is it visible 3D to 2D Convert to Shown

• Stores the current pixels to be displayed on the

• Monitor has no storage capabilities

• The framebuffer is copied to the monitor at each

• Application generates the

• System draws each one into the framebuffer

• Entire scene is redrawn anew every frame

OpenGL programmer does not need to implement

However, pipeline is reconfigurable

•Efficiently implementable in hardware

•Each stage can employ multiple specialized processors,

•#processors per stage, bus bandwidths are fully

• Vertices in world coordinates

• Vertices in world coordinates

• Transformer in world coordinates

• Transformer in world coordinates

• Mostly automatic (must set viewing volume)

• Complex transformation [Angel Ch. 4]

• Complex transformation [Angel Ch. 4]

• Interesting algorithms [Angel Ch. 6]

• Then, one can interpret them as:

• GL_POINTS, GL_LINES, GL_TRIANGLES

// (… fill the “vertices” array …)

glBegin (GL_POINTS); // or GL_LINES to render lines

glDrawArrays(GL_POINTS, 0, numVertices); // render points

Rendering: // (… fill the “vertices” array …)

glBegin(type); // create the VBO:

... glGenBuffers(1, &vbo);

int numVertices = 50000;

• Rendering of area (fill) depends on attributes

• Efficiency in space and time

You might also like