opengl: introduction yanci zhang game programming practice

OpenGL: OpenGL: IntroductionIntroduction

Yanci ZhangYanci Zhang

Game Programming PracticeGame Programming Practice

Overview of OpenGLOverview of OpenGL OpenGL vs. Direct XOpenGL vs. Direct X Rendering pipelineRendering pipeline Coordinate systemCoordinate system

OutlineOutline


OpenGL = Open Graphics LibraryOpenGL = Open Graphics Library Graphics rendering API Produce high-quality color images composed of 3D geometric

objects and images Hardware independentHardware independent Cross platformCross platform

What is OpenGL?What is OpenGL?


Bases for many advanced data structures in game Bases for many advanced data structures in game programmingprogramming

Typical applicationsTypical applications Scene graph State graph Decision tree Kd-tree, quad tree …

Basic FunctionBasic Function


Rendering basic primitives, like points, lines, triangles…Rendering basic primitives, like points, lines, triangles… Matrix operationsMatrix operations Local illuminationLocal illumination Texture mappingTexture mapping Pixel operationsPixel operations ……

What Can OpenGL Do?What Can OpenGL Do?


Create windowsCreate windows Handle window eventsHandle window events Response to user inputResponse to user input Scene managementScene management ……

What Can Not OpenGL What Can Not OpenGL Do?Do?


OpenGL is only graphics libraryOpenGL is only graphics library DirectX handles graphics, audio, user inputDirectX handles graphics, audio, user input

Use OpenGL improperly, system does nothing Use DirectX improperly, system does something beyond

expectation

OpenGL vs. DirectX OpenGL vs. DirectX 1/2


OpenGLOpenGL Industry standard maintained by OpenGL Architectural Review

Board (ARB) Stable function interface Cross platform Very clean, easy to learn

DirectXDirectX Microsoft’s product Instable function interface Only support Windows

OpenGL vs. DirectX OpenGL vs. DirectX 2/2


InputInput: : scene objects, lighting, camerascene objects, lighting, camera Most of the data is vertex list

OutputOutput: : pixels stored in framebufferpixels stored in framebuffer QuestionQuestion: : how to convert 3D vertex list to 2D pixels?how to convert 3D vertex list to 2D pixels? OpenGL is designed to fulfill this taskOpenGL is designed to fulfill this task

OpenGL PipelineOpenGL Pipeline

OpenGL Pipeline


Main task: transformation and lightingMain task: transformation and lighting Transformation:Transformation:

Model-View transformation: translation, rotation, scaling Projection transformation: perspective, parallel

LightingLighting Fixed-pipeline implements per-vertex lighting Lighting is normally delayed to fragment processing in

programmable pipeline

Vertex ProcessingVertex Processing


Assemble vertices into primitivesAssemble vertices into primitives Lines/Curves Triangles/Polygons/Surfaces

Primitive AssemblyPrimitive Assembly


Don’t render invisible objectsDon’t render invisible objects ClippingClipping

Remove primitives outside of the camera’s view frustum

Backface cullingBackface culling Remove triangles facing away from camera Usually cuts down $ of triangles by about

50%

Clipping and CullingClipping and Culling


Convert a primitive into a set of fragmentsConvert a primitive into a set of fragments Each pixel has both RGB color and depth Interpolate vertex color over fragments Fragment might not correspond to pixels on screen:

Occluded fragments

RasterizationRasterization


Assemble fragments into final framebufferAssemble fragments into final framebuffer Hidden-surface removal:Hidden-surface removal:

Some fragments may occlude parts of others Z-buffer sorts pixels by distance Handle transparency

Other operationsOther operations

Fragment Processing Fragment Processing


Using vertex list to represent a set rendering primitivesUsing vertex list to represent a set rendering primitives 14 primitives supported by OpenGL14 primitives supported by OpenGL

Point: GL_POINTS Line: GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP Triangle: GL_TRIANGLES, GL_TRIANGLE_STRIP,

GL_TRIANGLE_FAN Polygon: GL_QUADS, GL_QUAD_STRIP, GL_POLYGON

Rendering PrimitivesRendering Primitives


Polygons must obey following rulesPolygons must obey following rules Simple polygon Convex polygon Coplanar vertices

Triangle satisfies all the above rulesTriangle satisfies all the above rules Most common rendering primitive

Restriction on PolygonsRestriction on Polygons


Specifying Vertex Specifying Vertex 1/21/2


How to convert 3D objects to 2D image?How to convert 3D objects to 2D image? Just like taking a photograph!Just like taking a photograph!

Camera Analogy Camera Analogy 1/21/2

camera

tripod model

viewingvolume


Projection transformationsProjection transformations Adjust the lens of the camera

Viewing transformationsViewing transformations Tripod–define position and orientation of the viewing volume

in the world Modeling transformationsModeling transformations

Moving the model Viewport transformationsViewport transformations

Enlarge or reduce the physical photograph

Camera Analogy Camera Analogy 2/22/2


Steps in Forming an ImageSteps in Forming an Image Specify geometry (world coordinates) Specify camera (camera coordinates) Project (clip coordinates) Map to viewport (screen coordinates)

Each step uses transformationsEach step uses transformations Every transformation is equivalent to a change in Every transformation is equivalent to a change in

coordinate systems coordinate systems

Coord. Sys. and Coord. Sys. and TransformationsTransformations


Coord. Sys. and Coord. Sys. and TransformationsTransformations

Object Object CoordinatesCoordinates

World World CoordinatesCoordinates

Camera Camera CoordinatesCoordinates

Clip Clip CoordinatesCoordinates

Screen Screen CoordinatesCoordinates

Model Model TransformationTransformation

World World TransformationTransformation

Project Project TransformationTransformation

Viewport Viewport TransformationTransformation


Affine Transformations Affine Transformations 1/21/2

DefinitionDefinition

Using a single matrix multiplication to represent affine Using a single matrix multiplication to represent affine transformation by using augmented matrix and transformation by using augmented matrix and augmented vectoraugmented vector


Preserving geometryPreserving geometry lines, polygons, quadrics

Affine = line preservingAffine = line preserving Rotation, translation, scaling Projection Concatenation (composition)

Affine Transformations Affine Transformations 2/22/2


Each vertex is a column vector Each vertex is a column vector ww is usually is usually 1.01.0

(x,y,z,w) = (ax,ay,az,aw) If w is not 1.0, we can recover x,y,z by division by w Only perspective transformation change w

All operations are matrix multiplicationsAll operations are matrix multiplications Directions can be represented with Directions can be represented with w = w = 0.00.0

Homogeneous Homogeneous CoordinatesCoordinates

w

z

y

x

v


A vertex is transformed by 4 x 4 matricesA vertex is transformed by 4 x 4 matrices All affine operations are matrix multiplications All matrices are stored column-major in OpenGL Matrices are always post-multiplied Product of matrix and vector is

3D Transformations3D Transformations

v

M

151173

141062

13951

12840

mmmm

mmmm

mmmm

mmmm

M


Two waysTwo ways Specify matrices (glLoadMatrix, glMultMatrix) Specify operation (glRotate, glOrtho)

Obtain the desired matrix by a sequence of simple Obtain the desired matrix by a sequence of simple transformations that can be concatenated togethertransformations that can be concatenated together

Specifying Specifying TransformationsTransformations


Manage the matricesManage the matrices OpenGL provides matrix stacks for each type of transformation

Specify current matrix stackSpecify current matrix stackglMatrixMode(glMatrixMode(GL_MODELVIEW / GL_PROJECTION / GL_MODELVIEW / GL_PROJECTION /

GL_TEXTUREGL_TEXTURE)) Operations on matrix stackOperations on matrix stack

glLoadIdentity(): glLoadIdentity(): replaces the current matrix with the identity matrix glPushMatrix(): glPushMatrix(): pushes the current matrix stack down by one,

duplicating the current matrix glPopMatrix(): glPopMatrix(): pops the current matrix stack, replacing the current

matrix with the one below it on the stack glMultMatrix(): glMultMatrix(): multiply the current matrix by input matrix

Matrix StackMatrix Stack


Object coordinates to world coordinatesObject coordinates to world coordinates Call Call glMatrixModel(glMatrixModel(GL_MODELVIEWGL_MODELVIEW)) first ! first ! Move objectMove object glTranslate{fd}( x, y, z )glTranslate{fd}( x, y, z )

Rotate object around arbitrary axis Rotate object around arbitrary axis (x,y,z)(x,y,z) glRotate{fd}( angle, x, y, z )glRotate{fd}( angle, x, y, z )

Stretch or shrink objectStretch or shrink object glScale{fd}( x, y, z )glScale{fd}( x, y, z )

Modeling Modeling Transformations Transformations 1/31/3

obj

obj

obj

obj

world

world

world

world

w

z

y

x

w

z

y

x

modelM


Different transform order may produce different resultsDifferent transform order may produce different results Rotate then translate Translate then rotate



StepsSteps Suppose the current matrix is C Specify a model transform matrix M1 by:

glMultMatrix() glRotate(), glTranslate()…

Use CM1 to replace the current matrix on the top of matrix stack

Specify another model transform matrix M2

Now the current matrix is CM1M2

Transform vertex v: v’ = CM1M2v

You must specify the transform in reverse order! You must specify the transform in reverse order!



World coordinates to camera coordinatesWorld coordinates to camera coordinates Position the camera/eye in the scenePosition the camera/eye in the scene

Place the tripod down and aim cameragluLookAt(gluLookAt(eyeeyexx, eye, eyeyy, eye, eyezz, , aimaimxx, aim, aimyy, aim, aimzz, , upupxx, up, upyy, up, upzz))

Multiplies itself onto the current matrix up vector determines unique orientation

Viewing Viewing TransformationsTransformations

tripod

obj

obj

obj

obj

world

world

world

world

eye

eye

eye

eye

w

z

y

x

w

z

y

x

w

z

y

x

modelviewview MMM


Camera coordinates to clip coordinatesCamera coordinates to clip coordinates Perspective projectionPerspective projection

gluPerspective( fovy, aspect, zNear, zFar )gluPerspective( fovy, aspect, zNear, zFar )

glFrustum( left, right, bottom, top, zNear, zFar )glFrustum( left, right, bottom, top, zNear, zFar ) Feature: objects in the distance appear smaller than objects

close by

Projection Projection Transformation Transformation 1/21/2


Orthographic parallel projectionOrthographic parallel projectionglOrtho( left, right, bottom, top, zNear, zFar )glOrtho( left, right, bottom, top, zNear, zFar )

gluOrtho2D( left, right, bottom, top ) gluOrtho2D( left, right, bottom, top ) Feature: ignores perspective effect to allow accurate

measurements

Projection Projection Transformation Transformation 2/22/2


ViewportViewport Usually same as window size Viewport aspect ratio should be same as projection

transformation or resulting image may be distorted glViewport( x, y, width, height )glViewport( x, y, width, height )

Viewport Viewport TransformationTransformation


Why only one ModelView matrix stack instead of two Why only one ModelView matrix stack instead of two separated Model and View matrix stacks?separated Model and View matrix stacks?

Moving camera = Moving every object in the world Moving camera = Moving every object in the world towards a stationary cameratowards a stationary camera

Viewing transformations = Several modeling Viewing transformations = Several modeling transformationstransformations

Viewing and ModelingViewing and Modeling


Important: Important: OpenGL performs matrices multiplication in OpenGL performs matrices multiplication in reverse order if multiple transforms are applied to a reverse order if multiple transforms are applied to a vertexvertex Viewing transform comes first before modeling transform in

your code If you want to rotate then translate an object, put glTranslatef()

first then glRotatef()

Transform OrderTransform Order


opengl: introduction yanci zhang game programming practice

Documents