computer graphic -- programming with opengl i

C O M P U T E R G R A P H I C S

Jie chen

Computer graphic -- Programming with OpenGL I

2


Jie chen

What is new

• Website:

http://www.ee.oulu.fi/~jiechen/Course.htm

• Lecture slides for 3rd are online now

3


Jie chen

A Good news about VS2008A Good news about VS2008

4


Jie chen

VS2008

• A studentstudent of University of Oulu (Oulun Yliopisto) can download her/his own freefree copies of MS Visual Studio 2008 Professional Edition (and other software) here: https://www.dreamspark.com/ – This is a Microsoft's site where user requires an MS Live accoun

t (free) and that needs to be verified to be a student account from our university. This is done using the authentication service that our university provides and can be done with an account to Paju.

• Also our IT department also links to the site as one of the software sources for students (in Finnish only) http://www.oulu.fi/tietohallinto/opiskelijoille/ohjelmistot.html

5


Jie chen

Setup for VS2008• Run Visual C++ 2008. Go to Tools -> Options, then Projects and

Solutions -> VC++ Directories ->"Show directories for".– adding "include files” for the folder where you installed GLUT lib and

include folder.– adding “library files” for the folder where you installed gult32.lib.

6


Jie chen

Setup for VS2008• Go to Project -> Properties. Click on Configuration Properties. Click

the "Configuration Manager" button in the upper-right corner. Change the "Active solution configuration" from "Debug" to "Release". Click close, then click OK.

• In Project -> Properties, go to Configuration Properties -> General. Where it shows the output directory as "Release", backspace the word "Release", and click OK. – This makes Visual C++ put the executable in the same directory as the

source code, so when our program needs to open a file, it looks for it in that directory.

– In this case, the program will have to load in an image file called "vtr.bmp".

• Go to Build -> Build project_name to build your project.

• Run the program by going to Debug -> Start Without Debugging. If all goes well, the test program should run.

7


Jie chen

A simple example using OpenGL

8


Jie chen

A simple example using OpenGL

• Download the "basic shapes" program, and compile and run it (details on how to do that can be found in Lecture 3).

• Take a look at it, and hit ESC when you're done. • It should look like the following image:

9


Jie chen

Overview of How the Program Works

• How does the program work? – The basic idea is that we tell OpenGL

the 3D coordinates of all of the vertices of our shapes.

– OpenGL uses the standard x and y axes, with the positive x direction pointing toward the right and the positive y direction pointing upward.

– However, in 3D we need another dimension, the z dimension. The positive z direction points out of the screen.

10


Jie chen


• How does OpenGL use these 3D coordinates?

• It simulates the way that our eyes work.

eyes3D points

11


Jie chen


• OpenGL converts all of the 3D points to pixel coordinates before it draws anything.

• To do this, it draws a line from each point in the scene to your eye and takes the intersection of the lines and the screen rectangle, as in the above picture.

• So, when OpenGL wants to draw a triangle, it converts the three vertices into pixel coordinates and draws a "2D" triangle using those coordinates.

3D points

pixel coordinates

12


Jie chen


• The user's "eye" is always at the origin and looking in the negative z direction.

• Of course, OpenGL doesn't draw anything that is behind the "eye". – After all, it isn't the all-seeing eye of Sauron.

The eye of Sauron,The Lord of the Rings

13


Jie chen


• How far away is the screen rectangle from your eye?

• It doesn't matter. – No matter how far away the screen rectangle

is, a given 3D point will map to the same pixel coordinates.

– All that matters is the angle that your eye can see.

14


Jie chen

Going Through the Source Code

• All of this stuff about pixel coordinates is great and all, but as researcher or programmer, we want to see some code.

• Take a look at main.cpp.– Let's go through the file and see if we can und

erstand what it's doing.

15


Jie chen


• First, we include our header files. – Pretty standard stuff for C++. – If we're using a Mac, we want our program to i

nclude GLUT/glut.h and OpenGL/OpenGL.h; – otherwise, we include GL/glut.h.

16


Jie chen


• It just makes it so that we don't have to type std:: a lot;– for example, so we can use cout instead of s

td::cout.

17


Jie chen


• This function handles any keys pressed by the user.

• For now, all that it does is quit the program when the user presses ESC, by calling exit.

• The function is passed the x and y coordinates of the mouse, but we don't need them.

18


Jie chen


• The initRendering function initializes our rendering parameters. – The call makes sure that an object (O2) show

s up behind an object (O1).– Note that glEnable, like every OpenGL functi

on, begins with "gl".

19


Jie chen


• The handleResize function is called whenever the window is resized. – w and h are the new width and height of the w

indow.

20


Jie chen


• void gluPerspective(GLdouble fovy, GLdouble aspect,GLdouble near, GLdouble far);.– fovy =Θ=45.0: telling OpenGL the angle that user's eye can see. – Near=1.0: indicates not to draw anything with a z coordinate of s

maller than 1. This is so that when something is right next to our eye, it doesn't fill up the whole screen.

– Far= 200.0 tells OpenGL not to draw anything with a z coordinate larger than 200. We don't care very much about stuff that's really far away.

viewing volume

21


Jie chen


• So, why does gluPerspective begin with "glu" instead of "gl"? – gl: a OpenGL function– glu: a GLU (GL Utility) function– glut: a GLUT (GL Utility Toolkit) function– For examples:

• glRectf(-25.0, -25.0, 25.0, 25.0);• gluOrtho2D (0.0, w, 0.0, h);• glutSwapBuffers();

– We won't really worry about the difference among OpenGL, GLU, and GLUT.

• Just include “glut.h”, that is enough for Windows.

22


Jie chen


• The drawScene function is where the 3D drawing actually occurs. – call glClear to clear information from the last ti

me we drew. – In most every OpenGL program, you'll want to

do this.

23


Jie chen


• GL_COLOR_BUFFER_BIT: Color Buffer– OpenGL defined constants begin

with GL_, use all capital letters, and use underscores to separate words

– The Color Buffer store the color for each pixels of the current frame.

– The color is in RGBA mode i.e., Red, Green, Blue and Alpha.

– The first 3 components (RGB) can be considered as color of a pixel.

– Alpha value can be considered as the opacity or transparency of a pixel.

24


Jie chen

Going Through the Source Code• GL_DEPTH_BUFFER_BIT: Depth Buffer

– Depth Buffer holds the depth of each pixels of a frame. – It is also called z buffer. – Depth buffer is associated with Depth Test.– For each pixel drawn, Depth Test compare the current

depth stored in the depth buffer with the depth of the new pixel to draw.

– a pixel is drawn or not depending on result of depth test. – We usually use the depth buffer to draw nearest pixels

(p1), pixels behind are not drawn (p2).

viewing volume

p1 p2

25


Jie chen


• More about Buffer?

– http://jerome.jouvie.free.fr/OpenGl/Lessons/Lesson5.php

26


Jie chen


• For now, we'll ignore this.

• It'll make sense after the next lesson.

27


Jie chen

Going Through the Source Code• Draw the trapezoid (Begin the substance of our pr

ogram). – Call glBegin(GL_QUADS) to tell OpenGL that we want

to start drawing quadrilaterals. – Specify the four 3D coordinates of the vertices of the tra

pezoid, in order, using calls to glVertex3f. – After drawing quadrilaterals, call glEnd().

• Note that every call to glBegin must have a matching call to glEnd.

(-0.7f, -1.5f, -5.0f) (0.7f, -1.5f, -5.0f)

(0.4f, -0.5f, -5.0f)(-0.4f, -0.5f, -5.0f)

28


Jie chen

Going Through the Source Code• Draw the pentagon.

– To draw it, we split it up into three triangles, which is pretty standard for OpenGL.

– Calling glBegin(GL_TRIANGLES) to tell OpenGL that let us begin to draw triangles.

– Specify coordinates of the vertices.– OpenGL automatically puts the coordinates together i

n groups of three.– Each group of three coordinates represents one trian

gle.

29


Jie chen


• Finally, we draw the triangle.

• We haven't called glEnd() to tell OpenGL that we're done drawing triangles yet, so it knows that we're still giving it triangle coordinates.

30


Jie chen


• Finish drawing triangles -> call glEnd().• Note that we could have drawn the four triangles using fo

ur calls to glBegin(GL_TRIANGLES) and four accompanying calls to glEnd(). However, this makes the program slower, and you shouldn't do it.

• There are other things we can pass to glBegin in addition to GL_TRIANGLES and GL_QUADS, but triangles and quadrilaterals are the most common things to draw.

31


Jie chen


• This line makes OpenGL actually move the scene to the window.

• We'll call it whenever we're done drawing a scene.

32


Jie chen


• main function. – start by initializing GLUT.– In the call to glutInitWindowSize and set the window

to be 400x400. – Call glutCreateWindow to tell OpenGL what title we

want for the window. – Call initRendering to initialize OpenGL rendering.

33


Jie chen


• Point GLUT to the functions to handle keypresses and drawing and resizing the window.

• One important thing: – we're not allowed to draw anything except insi

de the drawScene function that we explicitly give to GLUT

34


Jie chen


• Call glutMainLoop, which tells GLUT to do its thing. – capture key and mouse input – draw the scene by calling our drawScene function – do some other stuff

• glutMainLoop like a defective boomerang, never returns. – GLUT just takes care of the rest of our program's execution.

• After the call, return 0 so that the compiler doesn't complain about the main function not returning anything, but the program will never get to that line.

• And that's how our first OpenGL program works.

35


Jie chen

More details about this example

36


Jie chen

OpenGL function format

glVertex4f(x,y,z,w)

belongs to GL library

function name

x,y,z,w are floats

glVertex4fv(p)

p is a pointer to an array

dimensions

gl: a OpenGL functionglu: a GLU (GL Utility) functionglut: a GLUT (GL Utility Toolkit) function

37


Jie chen

OpenGL function format

glVertex4f(x,y,z,w)

• x,y and z are coordinates and w is a factor, so the coordinates is equivalent to (x/w, y/w, z/w). • The default values of z and w are z =0 and w=1.• For examples:

glVertex4f(1, 2, 3, 3) -> glVertex4f(1/3, 2/3, 1, 1)

glVertex2f(1, 2) -> glVertex4f(1, 2, 0, 1)

glVertex3f(1, 2, 3) -> glVertex4f(1, 2, 3, 1)

i.e., z =0 and w=1

i.e., w=1

38


Jie chen

OpenGL function formatglVertex3f(x,y,z)

39


Jie chen

OpenGL Primitives

GL_POINTSGL_POINTS GL_LINESGL_LINES

GL_LINE_LOOPGL_LINE_LOOPGL_LINE_STRIPGL_LINE_STRIP

40


Jie chen

OpenGL Primitives

GL_QUAD_STRIPGL_QUAD_STRIP GL_POLYGONGL_POLYGON

GL_TRIANGLE_STRIPGL_TRIANGLE_STRIP GL_TRIANGLE_FANGL_TRIANGLE_FANGL_TRIANGLESGL_TRIANGLES

41


Jie chen

Polygon Issues

• OpenGL will only display polygons correctly that are– Simple: edges cannot cross– Convex: All points on line segment between two points in

a polygon are also in the polygon– Flat: all vertices are in the same plane

• User program can check if above true– OpenGL will produce output if these conditions are

violated but it may not be what is desired

• Triangles satisfy all conditions

nonsimple polygon

nonconvex polygon

p1

p2

42


Jie chen

Polygon Issues• How can we plot those polygons which do not satisfy these conditio

ns?– nonsimple polygon: edges DO cross– nonconvex polygon : There are points on line segment between two

points in a polygon are NOT in the polygon– Flat: all vertices are NOT in the same plane

• Solution: divide them using Triangles because triangles satisfy all conditions or quadrangle

nonsimple polygonnonconvex polygon

43


Jie chen

Polygon Issues

• Subdividing – to Improve a Polygonal Approximation to a Su

rface using approximating triangles

20 triangles 80 triangles 320 triangles

44


Jie chen

Polygon Issues

• Do something huge!

Demo

45


Jie chen

Polygon Issues

• Do something huge!

46


Jie chen

Hints for polygonizing surfaces

• Keep polygon orientations consistent– all clockwise or all counterclockwise– important for polygon culling and two-sided lig

hting • Watch out for any nontriangular polygons

– three vertices of a triangle are always on a plane; any polygon with four or more vertices might not

47


Jie chen

Hints for polygonizing surfaces

• There's a trade-off between the display speed and the image quality– few polygons render quickly but might

have a jagged appearance; millions of tiny polygons probably look good but might take a long time to render

– use large polygons where the surface is relatively flat, and small polygons in regions of high curvature

• Avoid T-intersections in our models – there's no guarantee that the line

segments AB and BC lie on exactly the same pixels as the segment AC

– this can cause cracks to appear in the surface

48


Jie chen

Some terms• Rendering: the process by which a computer creates

images from models.

• model, or object: constructed from geometric primitives - points, lines, and polygons - that are specified by their vertices.

• pixel: the smallest visible element that the display hardware can put on the screen. The final rendered image consists of pixels drawn on the screen.

• Bitplane: an area of memory that holds one bit of information (for instance, what color it is supposed to be) for every pixel on the screen.

• framebuffer : Organized by the bitplanes. It holds all the information that the graphics display needs to control the color and intensity of all the pixels on the screen.

pixel

49


Jie chen

24-bit true color

pixel

Bitplane

DAC: digital-to-analog converter

0 1 0 0 1 0 1 1

1 0 1 0 1 1 0 0

0 0 0 0 1 0 1 0

8 bit DAC

8 bit DAC

8 bit DAC

registers

Blue 75

Green 172

Red 10

Color Guns

Frame Buffer

CRT Raster

8

8

8

50


Jie chen

• The end of this lecture!

computer graphic -- programming with opengl i

Documents