363 Final Exam

Front 1

gluLookAt params

Back 1

X,y,z of eye, X,y,z of reference, X,y,z of up vector

Front 2

Basic OpenGL2 Pipeline

Back 2

Primitives (quads and triangles) -> Modelling (built in models, procedurally generated, user generated etc) -> Rendering (textures / illumination models) -> Animation (physics animation, procedurally generated animation)

Front 3

OpenGL Coordinate Frame

Back 3

RH Rule

Y index, thumb X, middle z.

Front 4

Homogeneous coordinates

Back 4

(X,y,z,h) - a point, (X/h,y/h,z/h) in Cartesian coordinates.

(X,y,z,0) - a vector

Front 5

Construct a model from triangle mesh:

Back 5

glBegin(GL_TRIANGLES):

glVertex3f(X1,y1,Z1);

.

.

.

glVertex3f(xn,yn,zn);

glEnd();

Front 6

Direction of vertices in a primitive triangle or quad

Back 6

Anti clockwise wrt to outward normal.

Front 7

Colour Combinations

Back 7

Red+Green = yellow

Green+Blue= cyan

Red+blue=magenta

Front 8

Specify colour values openGL

Back 8

glColor3f(0,1,1) or

glColor4f(0,1,1,1) with optional transparency value

Front 9

Frustrum Camera Model, glFrustrum parameters

Back 9

Front 10

Perspective Camera Model

Back 10

Front 11

Camera View

Back 11

gluLookAt() positions the camera in the world coordinate space, defining a transformation into the eye coordinate frame. The camera is at the origin of this frame, with y_e up, x_e pointing right and -z_e the view axis.

Front 12

Model-View Transformation

Back 12

Objects created in own local coordinate space then transformed into world coordinate space (then transformed again into coordinate space of camera to generate the view).

Front 13

Translation

Back 13

glTranslatef(a,b,c) - move a units in X direction, b units in y direction and c units in z direction.

Front 14

Rotation

Back 14

glRotatef(angle, l, m, n) - rotate angle degrees around axis of rotation l,m,n (right hand rotation rule).

Front 15

Scale

Back 15

glScalef(ax,sy,sz)

Self explanatory

Front 16

Independent transformation of only one object. - make a cube then translate it then scale it.

Back 16

glPushMatrix();

glScalef(1,4,4);

glTranslatef (3,0,2);

glutSolidCube(3);

glPopMatrix();

Front 17

Rotate about a pivot point (px,py,pz)

Back 17

All openGL rotations are done with origin as pivot point. Translate pivot point to origin, perform rotation, translate back.

glTranslatef (px,py,pz);

glRotatef (90,0,1,0);

glTranslatef(-px,-py,-pz);

glutSolidCube (1);

Front 18

Local Illumination Model

Back 18

Colour at each vertex is computed using position of light and vertex, surface normal orientation at vertex, position of viewer.

Does not take into account other info, eg light reflected from other objects.

Front 19

Ambient Reflection

Back 19

Constant background light, does not depend on light/viewer positions or surface orientation. Typically defined as a low intensity gray, L_a = (0.2,0.2,0.2).

If material colour is M_a:

Ambient Reflection I_a = L_a M_a

Front 20

Diffuse Reflection

Back 20

Intensity depends on orientation of surface relative to light direction. Max at angle 0, min at angle >= 90. Light diffuse colour L_d usually (1,1,1).

Light source vector l, normal vector n both normalised then cos(theta) = l•n.

The diffuse Reflection

I_d = L_d M_d * max(l•n, 0)

Front 21

Specular Reflection + shininess

Back 21

Bright reflections from mirror or polished surfaces. Specular reflection maximised when view vector (v, unit) is equal to direction of reflection (r, unit) from the light source.

M_s material specular colour usually set to white to provide bright highlight.

L_s = light's specular colour.

"Shininess" refers to the width of the specular highlight. Higher shininess = less spread and more concentrated highlight. Phong's constant/shininess term f controls diameter of highlight. High values give more concentrated highlights.

Specular reflection:

I_s = L_s M_s * (max(r • v, 0))^f

Front 22

Vertex lighting

Back 22

OpenGL calculates lighting at each vertex, polygon interiors are filled with interpolation. Face normal vectors assign the same normal to all 3/4 face vertices, so shape looks blocky. Vertex normals give a smooth variation of shades on surface.

Front 23

OpenGL2 Spotlights

Back 23

Lights are omnidirectional by default. Make spotlight by specifying

- spot cutoff angle (half cone angle of spotlight)

- spot direction (vector specifying cone axis)

- spot exponent (higher means faster drop off in intensity away from center of spotlight)

Front 24

Types of Shadow

Back 24

Backface Shadows - Shadow on the surface of the object when it is oriented away from light, generated by illumination model.

Projected shadows - shadows cast on other surfaces, not generated in openGL 2 lighting model.

Front 25

Rendering polygons

Back 25

Vertices just be specified anticlockwise. Polygon must be convex. Specify using GL_POLYGON or triangle/quad to be more specific.

Front 26

GL_TRIANGLE_FAN

Back 26

Front 27

GL_TRIANGLE_STRIP or GL_QUAD_STRIP

Back 27

Front 28

Sweep Surface

Back 28

Surface done by transforming a polygonal element, eg volume of revolution and connecting points between transformative by triangle or quad strips.

Front 29

Texture Environment

Back 29

GL_REPLACE - primitive colour completely replaced with texture.

GL_MODULATE - primitive colour multiplied by fragment colour.

Front 30

Texture coordinates

Back 30

(s,t) with s and t between 0 and 1. Corresponding to the coordinates of the image ( (0,0) in bottom left)

Front 31

Texture Tiling

Back 31

When setting wrap parameters for s or t:

If GL_CLAMP set, texture coordinate values over 1 are treated as 1 (so you get a stretchy look after the initial image).

If GL_REPEAT set values over 1 are taken mod 1 so the image repeats like a tile.

Front 32

Texel

Back 32

The pixel value of a texture.

Front 33

Texture Magnification/Minification

Back 33

When mapping a small texture to a larger polygon (magnification) or a large texture to a smaller polygon (minification):

GL_NEAREST sets each pixel to get the colour of the texel value closest to the centre of the pixel (more blocky).

GL_LINEAR sets the pixel value to be the weighted average of the 4 texel values closest to the centre of the pixel (more blurry).

Front 34

Mipmaps

Back 34

Thin lines often disappear during minification.

Mipmap = a set of prefiltered versions of the same image at different scales (resolutions).

Requires extra processing and texture storage space but reduces aliasing effects as different images can be used in different scenarios.

Front 35

Angle between vectors (and obtuse Vs acute(

Back 35

cos(theta) = v1•v2 / ||v1||•||v2||

If cos(theta) > 0, acute

If cos(theta) < 0, obtuse

Front 36

Surface normal at vertex

Back 36

Take cross product of 2 vectors going to adjacent vertices.

Front 37

Translation matrix

Back 37

Front 38

Scale Matrix

Back 38

Front 39

Affine Transformation

Back 39

A general linear transformation followed by a translation. Examples: translation, rotation, scaling, shear transformations.

Under affine transformations, line segments transform into line segments and parallel lines transform into parallel lines.

Front 40

Linear Interpolation

Back 40

Interpolate some value v between end points v1 and V2:

V = (1-t)v1 + tv2

Front 41

Bilinear Interpolation

Back 41

Given values of an attribute at vertices of a triangle, we want to obtain values at interior points. For triangle vertices A,B,C:

Compute:

D = (1-t)A + tB

E = (1-t)A + tC

Then bilinearly interpolated value is:

F = (1-s)D + sE

Hint 41

Front 42

Phong Blinn Illumination Model

Back 42

Front 43

Halfway vector and it's advantages

Back 43

h = (l + v) normalised.

If theta is angle between r and v and beta is angle between h and n they are correlated and 0 at the same time. So OpenGL uses h•n to approximate r•v in specular lighting calculations.

Advantages:

Easier to compute h than r

If l is directional source and view direction is constant, h only needs to be computed once for the whole scene.

Front 44

Local / Global Illumination

Back 44

Local Illumination: considers only light traveling from a light source to a surface, reflected to the eye. Does not consider occlusions and transmittance of light.

Global illumination: illumination at a given point is a combination of the light received from a source and the light reflected from other surfaces in the scene.

Front 45

Ray Tracing

Back 45

Generate a 2D image pixel by pixel by computing the colour cake of each pixel via rays generated from the eye position through the degree of the pixel.

Along each primary ray calculate the closest point of intersection (if none assign background colour), then use secondary rats to model shadows, reflections, refractions to return overall colour.

Front 46

Ray

Back 46

Specified by a point p (source of ray) and a unit vector d (direction of ray) with ray parameter t.

Ray's equation: p = p0 + td

Front 47

Ray Casting

Back 47

Use only primary rays, and material colour at point of intersection.

With no lighting, looks 2D.

With Phong illumination, gain specular highlights, diffuse lighting, but no reflections, refraction etc.

Front 48

OpenGL 4 Motivation

Back 48

The ability to program graphics hardware allows a wider range of rendering effects that give optional performance.

Developers have more freedom to define actions to be taken at each stage of processing.

Front 49

OpenGL 4 Programmable Pipeline overview

Back 49

Program and memory (eg vertex data) does in CPU. Shaders in GPU.

Application sends vertex data, transformation matrices to vertex shader which does transformation and lighting calcs. It outputs vertices in clip coordinates to fragment shader, application sends image/texture pixel values to fragment shader. Fragment shader outputs colour after texturing, interpolation etc.

Front 50

OpenGL4 Shader Stages

Back 50

Vertex shader -> tessellation control shader -> primitive generator -> tessellation evaluation shader -> geometry shader -> primitive assembly, clipping, viewport transformation -> rasterization -> fragment shader -> fragment tests -> frame buffer

Front 51

Vertex Buffer Objects

Back 51

Represents the data (coords, colour, normal) for a particular vertex attribute in video memory. Stored in a vertex array object which encapsulates all vertex data.

To create a vbo, generate a new buffer object, bind buffer object to target, copy vertex data to buffer.

To create a vao, generate new vertex array object, bind it (initially empty), create constituent vbo's and transfer data.

Front 52

Vertex Shader

Back 52

Executed once per vertex (multiple in parallel).

Position, normal, colour, texture coordinates etc of current vertex available in shader. Positions and attributes of other vertices not available.

Vertex shader outputs the clip coordinates of the current vertex, performs lighting calculations.

gl_Position is built in out variable for vertex shader, must be defined. Per vertex colour outputs are optional.

Front 53

Rasterization

Back 53

Process of scan converting a primitive into a set of fragments.

A fragment is a pixel sized element that belongs to a primitive and could potentially be displayed as a pixel. Num of generated fragments depends on projected area of the primitive in the screen coordinate space.

Front 54

Fragment Shader

Back 54

Gets values from previous stage, not VBO.

Executed once per fragment generated by the rasterizer. Outputs colour of fragment and optionally the depth value. Colour computations such as texture mapping, depth offsets etc can be performed. Can also discard a fragment.

Built in variables gl_FragCoord, gl_FragColor, gl_FragDepth

Front 55

Uniform Variables

Back 55

Mechanism for transferring matrices and other values from application to shader.

Front 56

Important Matrices

Back 56

Model View Matrix (VM) - product of view matrix and transformation matrices, converts view coordinates into eye coordinates to do lighting calculations (easier in this coordinate system since camera is at the origin).

Model View Projection Matrix (PVM) - product of Model View Matrix and projection matrix, converts view coordinates to clip coordinates.

Both sent to shaders.

Clip coordinate = projection matrix * view matrix * transformation matrix * world coordinate

Front 57

Transformation of a Normal Vector

Back 57

If points are transformed by a matrix A, the normal vectors must be transformed by

(A^T)^-1

To remain normal to the transposed surface.

Front 58

Parametric Domain Definition and 2D Types

Back 58

A space defined by a regular shape, within which points are specified using parametric values between 0 and 1.

Types:

Quad domain - a unit square.

Triangle domain - given in barycentric coordinates, (u,v,w).

Front 59

Mapping Parametric Domain to a General shape in 3D space (both quad and triangle)

Back 59

Quad: Use bilinear Interpolation formula:

Q = (1-v)((1-u)P0 + uP1) + v((1-u)P3 + uP4)

Triangle: use barycentric mapping:

Q = uP0 + vP1 + wP2

Front 60

Tessellating Parametric Domains - why and details

Back 60

Tesselating arbitrary shapes hard, easier to tessellate eg a square and map it into a general quad. (u,v) or (u,v,w) called tessellation coordinates.

Front 61

Tesselation Levels

Back 61

Outer tesselating levels specify the number of subdivisions on the edges of the domain.

Inner tesselation levels specify the minimum number of subdivisions from one side to the other.

For a quad : two inner levels, horizontal and vertical.

For a triangle : one inner level for all 3 directions.

Quad specified by ooooii

Triangle specified by ooo0i0 (extra gap filled with 0 for both outer and inner).

Front 62

Tesselation Control Shader

Back 62

Tesselation control shader receives patch vertices (gl_in), specifies outer and inner tesselation levels and can modify patch vertices if needed. Generally we use this to add higher levels of detail to objects closer to the camera (higher tesselation levels). We theoretically could just leave it as a pass through shader to have everything in the same detail.

Front 63

GL_PATCHES

Back 63

A patch is an ordered list of vertices. It is not a renderable primitive so the vertex shader doesn't convert patch vertices to clip coordinates. GL_PATCHES must be passed to the vertex shader if the tesselation stage is active.

Front 64

gl_in

Back 64

The built in array variable through which the shader accesses the patch vertices.

Front 65

Primitive Generator

Back 65

Primitive generator outputs triangles of the tessellated mesh with vertices in tesselation coordinates. These triangles form tessellations of square or triangle domains. Vertices of each triangle will have normalised coordinates.

These are sent to the evaluation shader.

Front 66

Tesselation Evaluation Shader

Back 66

Tesselation evaluator specifies blending functions and combines patch vertices with tesselation coordinates to position vertices of the generated mesh on the patch. It converts 2D primitive vertices (u,v) to 3D points in clip coordinates.

Front 67

Vertex shader if tesselation or geometry stages on

Back 67

Just a pass through shader

Front 68

Geometry shader overall ideas

Back 68

Receives input from TES or vertex shader if tesselation not active. Input is primitives with vertices stored in an array, geometry shader runs once per entire primitive (has much more information than eg a vertex shader).

The shader can change the type of input primitive and the number of vertices or discard primitives. It can output values into multiple streams.

It outputs each vertex in clip coordinates using the built in gl_position variable.

Front 69

Geometry shader input and output types, built in output functions

Back 69

INPUT: Any primitives: points, lines, line strip, triangles, quads etc. Also GL_TRIANGLES_ADJACENCY.

OUTPUT: points, line strip or triangle strip (triangles and quads are special cases of triangle strips).

Outputs vertices using built in function EmitVertex(). End whole primitive with EndPrimitive(). If shader exits without emitting a vertex then it does not produce any output primitive.

Front 70

Adjacency Primitives

Back 70

GL_LINES_ADJACENCY: 4 vertices per primitive, 2nd and 3rd form current line, other two are just tested as adjacent.

GL_TRIANGLES_ADJACENCY: 6 vertices per primitive. 1st, 3rd and 5th form current triangle.

When adjacency primitive is drawn without geometry shader only current primitive vertices are drawn and the others discarded.

If geometry shader is active it gets all vertices of adjacency primitive in gl_in[].gl_position array. It can modify attributes of the current triangle or generate additional primitives using information about adjacent triangles.

Front 71

Geometry culling

Back 71

Shader can discard a primitive as a whole.

Front 72

Geometry amplification

Back 72

Example:

The application generates a 2D strip line, geometry shader receives individual lines of the strip (X1,y1), (X2,y2) and outputs Triangles strip for each line received.

When done on repeat could create eg a volume of revolution.

Front 73

Uses of geometry shader

Back 73

More complex lighting/texture calculations than previously possible due to being able to work with whole primitive at once and having neighbouring vertex info.

Eg can be used for lighting and height based texture mapping in terrain construction.

Front 74

Terrain Construction Stages

Back 74

Construct terrain base (application).

Tesselate the base to the required level (control shader).

Reposition (u,v) using patch coordinates (evaluation shader).

Use height map to modify vertices of the tessellated mesh (evaluation shader).

Perform lighting computation and height based texture mapping (geometry shader).

Front 75

List 2 Uses of Vertex Shader

Back 75

Transformation - position vectors from world to clip coordinates via MVP matrix.

Lighting - position and normal vectors from world to eye coordinates via MV and normal matrices.

Front 76

List 2 Uses of Tesselation Control Shader

Back 76

Specify Inner and Outer Tessellation levels.

Modify patch vertices if necessary.

Front 77

Specify purpose of primitive generator

Back 77

Output mesh of triangle primitives in tessellation coordinates determined by the specified tessellation levels.

Front 78

List 2 Uses of Tesselation evaluation shader

Back 78

Reposition each mesh vertex in (u,v) tessellation coordinates using patch vertices.

Output vertex positions in clip coordinates. (Or world sometimes).

Front 79

List uses of geometry shader

Back 79

Geometry culling - discard primitives, eg if not in view.

Perform lighting/texture calculations.

Output multiple primitives in different streams if needed (eg for geometry amplification).

Front 80

List 3 uses of fragment shader

Back 80

Perform lighting and texturing calculations for each fragment by interpolating vertex values.

Perform optional depth calculations.

Optionally discard fragments if needed.

Front 81

Conditions for being in shadow

Back 81

Distance to object is less than distance to light on secondary ray. t value is positive.