OpenGL and Parametric
Curves
Advanced Multimedia Technology: Computer Graphics
Yung-Yu Chuang
2005/12/21
with slides by Brian Curless, Zoran Popovic, Robin Chen and Doug J ames
Review of graphics pipeline
Review of graphics pipeline
Review of graphics pipeline
• Rasterization • Visibility
Review of graphics pipeline
OpenGL
• A low-level OS-independent graphics API for 2D and 3D interactive graphics.
• Initiated by SGI (called GL at early time) • Implementation, for Windows, hardware
vendors provide suitable drivers for their own products; for Linux, we have Mesa.
Helper libraries
• OpenGL does not provide OS-dependent functions such as windowing and input
– GL: core graphics functions
– GLU: graphics utilities in top of GL – GLUT: input and windowing functions
How does it work?
• From the programmer’s view
– Specify geometric properties of the objects – Describe material properties
– Define viewing
– Define camera and object transformations
• OpenGL is a state machine
– States: color, material properties, line width, current viewing
– States are applied to subsequent drawing commands – Input: description of geometric objects
How does it work
• From the implementer’s perspective • Graphics pipeline Primitives + material properties Rotate Translate Scale Is it Visible? 3D to 2D Scan conversion Visibility determination Display
Primitives: drawing a polygon
// put GL into polygon drawing mode glBegin(GL_POLYGON); // define vertices glVertex2f(x0, y0); glVertex2f(x1, y1); glVertex2f(x2, y2); glEnd();
Primitives
Polygon restrictions
• In OpenGL, polygons must be simple and convex
Attributes
• Part of the state of the graphics pipeline • Set before primitives are drawn.
• Remain in effect! • Example:
– Color, including transparency – Reflection properties
Primitives: material properties
• glColor3f(r,g,b);
All subsequent primitives will use this color. Colors are not attached to objects. The above command only changes the system states.
• OpenGL uses red, green and blue color model. Each components are ranged within 0 and 1.
Simple transformations
• Rotate by a given angle (in degrees) about ray f rom origin through (x,y,z)
glRotate{fd}(angle, x, y, z);
• Translate by a given x, y, z values
glTranslate{fd}(x, y, z);
• Scale with a factor in the x, y, and z directions
glScale{fd}(x, y, z);
Orthographic projection
Camera transformations
• gluLookAt(eyex, eyey, eyez, cx, cy, cz, upx, up y, upz);
Callback functions
• Handle “events”, Idle, Keyboard, Mouse, Menu, Motion, Reshape
• The display callback is installed by glutDisplayF unc()
Results
Depth buffer in OpenGL
• glutInitDisplayMode(GLUT_DEPTH); • glEnable(GL_DEPTH_TEST);
Double buffering
• Flicker if drawing overlaps screen refresh • Solution: use two frame buffers
– Draw into one buffer
– Swap and display, while drawing other buffer
• glutInitDisplayMode(GLUT_SINGLE) • glutInitDisplayMode(GLUT_DOUBLE) • glutSwapBuffers()
Example: rotate a color cube
Example: rotate a color cube
• Step 2: enable depth testing and double buffering
Example: rotate a color cube
Example: rotate a color cube
• Step 4: reshape callback, enclose cube, preserve aspect ratio
Example: rotate a color cube
• Step 5: display callback, clear, rotate, draw, flush, swap
Example: rotate a color cube
• Step 6: draw cube by drawing faces, orientation consistency
Example: rotate a color cube
Example: rotate a color cube
• Step 8: animation, set idle callback spinCube
Example: rotate a color cube
• Step 9: change axis of rotation using mouse callback
Example: rotate a color cube
• Step 10: toggle rotation or exit using keyboard callback
Cubic curves
N too small less flexibility in controlling the shape of → the curve
Constrain the cubics
Hermite: defined by two endpoints and two endpoint tangent vectors
Bezier: defined by two endpoints and two other points that control the endpoint tangent vectors
Bezier curve
•each is between 0 and 1
What do we want for a curve?
• Local control • Interpolation • Continuity
Local control
• One problem with Bezier curve is that every control points affect every point on the curve (except for endpoints). Moving a single control point affects the whole curve.
• We’d like to have local control, that is, have each control point
affect some
well-defined neighborhood around that point.
Interpolation
• Bezier curves are approximating. The curve
does not necessarily pass through all the control points. We’d like to have a curve that is
interpolating, that is, that always passes through every control points.
Continuity
• We want our curve to have continuity: there shouldn’t be any abrupt changes as we move along the curve.
Splines
• We will splice together a curve from individual Bezier segments. We call these curves splines. When splicing Bezier together, we need to worr y about continuity.
