Computer Graphics Software
Graphics Software
There are two types of graphics software
Special purpose packages
For non programmers
The interface is a set of menus that facilitate communication
E.g. CAD, CAM, painting, animation
General programming packages
Provides a library of graphics functions that can be used in
a programming language such as C, C++, Java, …
Library of graphics functions (OpenGL)
Picture components (lines, shapes, …)
Transformations (color, texture, shading, rotating, …)
Coordinate Representations
To generate a picture using a programming
package, we first need to give the geometric
descriptions of the objects – location and shape
For example, a box is specified by the positions of
its corners, a sphere is specified by its center
position and radius
General graphics packages require geometric
descriptions to be specified in a standard, right-
handed, Cartesian-coordinate reference frame.
Graphics Rendering Pipeline
Rendering: conversion from scene to image
Scene is represented as a model composed of primitives.
Model is generated by a program or input by a user.
Image is drawn on an output device: monitor, printer,
memory, file, video frame. Device independence.
Typically rendering process is divided into steps called the
graphics pipeline.
Graphics Rendering Pipeline
Cartesian reference frames used in constructing and
displaying a scene
Modeling / local / master coordinates (MCS) used to define
the shapes of individual objects, such as trees or furniture
A Scene is constructed by placing the objects into appropriate
locations within a scene reference frame called world
coordinates (WCS)
The overall WC description is processed through various
routines onto one or more output-device reference frames for
display in a process called the viewing pipeline
WC positions are first converted to viewing coordinates
corresponding to the view we want of a scene, based on the
position and orientation of a hypothetical camera.
Graphics Rendering Pipeline
Then object locations are transformed to a two-dimensional
(2D) projection of the scene, which corresponds to what we
will see on the output device.
The scene is then stored in normalized coordinates /
normalized device coordinates, where each coordinate
value is in the range from −1 to 1 or 0 to 1, depending on the
system
Visible surfaces are identified and picture parts outside the
bounds for the view are eliminated.
The picture is scan-converted into the refresh buffer of a
raster system for display. The coordinate systems for display
devices are generally called device coordinates, or screen
coordinates in the case of a video monitor.
Forward projection pipeline
Graphics Functions
Graphics Output Primitives (building blocks)
Character strings, lines, filled color areas
(usually polygons)
Basic tools for constructing pictures
Attributes
Color, line style, text style, area filling patterns
Geometric Transformations
Change size, position or orientation of an
object
Algorithms
A number of basic algorithms are needed:
Transformation: Convert representations of models/primitives
from one coordinate system to another
Clipping/Hidden surface removal: remove primitives and part of
primitives that are not visible on the display
Rasterization: Convert a projected screen space primitive to a set
of pixels.
Picking: select a 3D object by clicking an input device over a
pixel location.
Shading and illumination: Simulate the interaction of light with a
scene.
Animation: Simulate movement by rendering a sequence of
frames.
Early History of APIs
The primary goal of standardized graphics
software is portability
The first graphics API was
Graphical Kernel System (GKS)
2D but contained good workstation model
GKS adopted as IS0 and later ANSI standard
(1984)
GKS not easily extended to 3D (GKS-3D)
Far behind hardware development
PHIGS and X
Programmers Hierarchical Graphics System
(PHIGS)
Arose from CAD community in 1988
Database model with retained graphics (structures)
X Window System
DEC/MIT effort
Client-server architecture with graphics
PEX combined the two
Not easy to use (all the defects of each)
Phigs+, GL, OpenGL, Direct3D: 3D pipeline
OpenGL
Silicon Graphics, Inc. (SGI) developed graphics
workstations with a set of routines called GL
(Graphics Library),
The success of GL lead to OpenGL (1992), a
platform-independent API that was
Easy to use
Close enough to the hardware to get excellent
performance
Focus on rendering
Omitted windowing and input to avoid window
system dependencies
OpenGL Evolution
Originally controlled by an Architectural
Review Board (ARB)
Members included SGI, Microsoft, Nvidia, HP,
3DLabs, IBM,…….
Relatively stable (present version 4.6)
Evolution reflects new hardware capabilities
3D texture mapping and texture objects
Vertex programs
Allows for platform specific features through
extensions
ARB replaced by Kronos
OpenGL Libraries
OpenGL core library
OpenGL32 on Windows
GL on most unix/linux systems (libGL.a)
OpenGL Utility Library (GLU)
Provides functionality in OpenGL core but avoids
having to rewrite code
Links with window system
GLX for X window systems
WGL for Windows
AGL for Macintosh
Basic OpenGL Syntax
Function names are prefixed with gl for core
library, glu for GLU, glut for GLUT library
glBegin, glClear, gluOrtho2D,glutInit
Constants
GL_2D, GL_RGB, GLUT_SINGLE
Data types
GLbyte, GLshort, GLint, GLfloat, GLdouble
GLUT
OpenGL Utility Toolkit (GLUT)
Provides functionality common to all window
systems
Open a window
Get input from mouse and keyboard
Menus
Event-driven
Code is portable but GLUT lacks the functionality
of a good toolkit for a specific platform
No slide bars
Software Organization
application program
OpenGL Motif
widget or similar GLUT
GLX, AGL
or WGL GLU
X, Win32, Mac O/S GL
software and/or hardware
OpenGL Architecture
Immediate Mode geometry
pipeline
Per Vertex
Polynomial Operations &
Evaluator Primitive
Assembly
Display Per Fragment Frame
CPU List
Rasterization
Operations Buffer
Texture
Memory
Pixel
Operations
OpenGL Functions
Primitives
Points
Line Segments
Polygons
Attributes
Transformations
Viewing
Modeling
Control (GLUT)
Input (GLUT)
Query
OpenGL State
OpenGL is a state machine
OpenGL functions are of two types
Primitive generating
Can cause output if primitive is visible
How vertices are processed and appearance of
primitive are controlled by the state
State changing
Transformation functions
Attribute functions
Lack of Object Orientation
OpenGL is not object oriented so that there
are multiple functions for a given logical
function
glVertex3f
glVertex2i
glVertex3dv
Underlying storage mode is the same
Easy to create overloaded functions in C++
but issue is efficiency
OpenGL function format
function name
dimensions
glVertex3f(x,y,z)
belongs to GL library x,y,z are floats
glVertex3fv(p)
p is a pointer to an array
OpenGL Command Formats
glVertex3fv( v )
Number of Data Type Vector
components b - byte
ub - unsigned byte omit “v” for
2 - (x,y)
3 - (x,y,z)
s - short scalar form
us - unsigned short
4 - (x,y,z,w)
i - int
ui - unsigned int glVertex2f( x, y )
f - float
d - double
OpenGL #defines
Most constants are defined in the include
files gl.h, glu.h and glut.h
Note #include <GL/glut.h> should
automatically include the others
Examples
glBegin(GL_POLYGON)
glClear(GL_COLOR_BUFFER_BIT)
include files also define OpenGL data
types: GLfloat, GLdouble,….
A Simple Program
Generate a square on a solid background
simple.c
#include <GL/glut.h>
void mydisplay(){
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glVertex2f(-0.5, -0.5);
glVertex2f(-0.5, 0.5);
glVertex2f(0.5, 0.5);
glVertex2f(0.5, -0.5);
glEnd();
glFlush();
}
int main(int argc, char** argv){
glutCreateWindow("simple");
glutDisplayFunc(mydisplay);
glutMainLoop();
}
Event Loop
Note that the program defines a display
callback function named mydisplay
Every glut program must have a display callback
The display callback is executed whenever
OpenGL decides the display must be refreshed,
for example when the window is opened
The main function ends with the program
entering an event loop
Compilation on Windows
Visual C++
Get glut.h, glut32.lib and glut32.dll from web
Create a console application
Add opengl32.lib, glut32.lib to project settings
(under link tab)
Borland C similar
Cygwin (linux under Windows)
Can use gcc and similar makefile to linux
Use –lopengl32 –lglu32 –lglut32 flags
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
nonconvex polygon
nonsimple polygon
Attributes
Attributes are part of the OpenGL state and
determine the appearance of objects
Color (points, lines, polygons)
Size and width (points, lines)
Stipple pattern (lines, polygons)
Polygon mode
Display as filled: solid color or stipple pattern
Display edges
Display vertices
RGB color
Each color component is stored separately in the
frame buffer
Usually 8 bits per component in buffer
Note in glColor3f the color values range from 0.0
(none) to 1.0 (all), whereas in glColor3ub the
values range from 0 to 255
Color and State
The color as set by glColor becomes part of the
state and will be used until changed
Colors and other attributes are not part of the
object but are assigned when the object is
rendered
We can create conceptual vertex colors by code such
as
glColor
glVertex
glColor
glVertex
Viewports
Do not have to use the entire window for
the image: glViewport(x,y,w,h)
Values in pixels (screen coordinates)
Geometric Primitive Types
Geometric Primitive Types
GL_POINTS : Draws a point at each of the n vertices.
GL_LINES : Draws a series of unconnected line segments.
Segments are drawn between v0 and v1, between v2 and v3,
and so on. If n is odd, the last segment is drawn between vn-3
and vn-2, and vn-1 is ignored.
GL_LINE_STRIP : Draws a line segment from v0 to v1,
then from v1 to v2, and so on, finally drawing the segment
from vn-2 to vn-1. Thus, a total of n-1 line segments are
drawn. Nothing is drawn unless n is larger than 1. There are
no restrictions on the vertices describing a line strip (or a line
loop); the lines can intersect arbitrarily.
GL_LINE_LOOP : Same as GL_LINE_STRIP, except that
a final line segment is drawn from vn-1 to v0, completing a
loop.
Geometric Primitive Types
GL_TRIANGLES : Draws a series of triangles (three-
sided polygons) using vertices v0, v1, v2, then v3, v4, v5,
and so on. If n isn't an exact multiple of 3, the final one or
two vertices are ignored.
GL_TRIANGLE_STRIP : Draws a series of triangles (three-
sided polygons) using vertices v0, v1, v2, then v2, v1, v3
(note the order), then v2, v3, v4, and so on. The ordering is
to ensure that the triangles are all drawn with the same
orientation so that the strip can correctly form part of a
surface. Preserving the orientation is important for some
operations, such as culling.
GL_TRIANGLE_FAN :Same as GL_TRIANGLE_STRIP,
except that the vertices are v0, v1, v2, then v0, v2, v3, then
v0, v3, v4, and so on.
Geometric Primitive Types
GL_QUADS : Draws a series of quadrilaterals (four-sided
polygons) using vertices v0, v1, v2, v3, then v4, v5, v6, v7,
and so on. If n isn't a multiple of 4, the final one, two, or
three vertices are ignored.
GL_QUAD_STRIP: Draws a series of quadrilaterals (four-
sided polygons) beginning with v0, v1, v3, v2, then v2, v3,
v5, v4, then v4, v5, v7, v6, and so on. n must be at least 4
before anything is drawn. If n is odd, the final vertex is
ignored.
GL_POLYGON :Draws a polygon using the points v0, ... ,
vn-1 as vertices. n must be at least 3, or nothing is drawn. In
addition, the polygon specified must not intersect itself and
must be convex. If the vertices don't satisfy these conditions,
the results are unpredictable.
Header files
• #include <windows.h>
• #include <GL/gl.h>
• #include <GL/glu.h>
With GLUT we don’t need glu.h and gl.h
• #include <GL/glut.h>
• Include header files for the C++ program
• #include <stdio.h>
• #include <stdlib.h>
• #include <math.h>
DISPLAY WINDOW MANAGEMENT USING GLUT
To initialize glut------glutInit(&argc, argv)
Window caption----glutCreateWindow("My
first opengl program")
To specify what the display window will
contain you can use a method for example “
line_segment”
Use glutDisplayFunc(line_segment) to call
the method in the main program
COMPLETE THE OPERATIONS
• To complete the processing operations, use the
following function------glutMainLoop()---the very
last function of the program.
• Initial image position----
glutInitWindowposition(100,200)
• Initial window size-----
glutInitWindowSize(200,300)
• Other window options like buffering and choice of
color modes
• glutDisplayMode(GLUT_SINGLE|GLUT_RGB)
A complete OpenGL program
Set background colour ---
glClearColor(1.0,1.0,1.0,1.0)
Putting the display window on the screen
use---glClear(GL_COLOR_BUFFER_BIT)
Choosing colour schemes for objects---
glColor3f(1.0,0.0,0.0)
CONT…
If we want to display 2D object, we tell the
OpenGL how we want to project our picture
onto the display window as generating 2D is
a special case of 3D viewing
glMatrixMode(GL_PROJECTION)
gluOrtho2D(0.0,200.0,0.0,150.0)
CONT..
Create “line_segement” by calling
appropriate OpenGL routines
glBegin(GL_LINES);
glVertex2i(180,15);
glVertex2i(10,145);
glEnd();
glFlush();
IMPLEMENTATION
// Include Header files
#include<windows.h>
#include<GL/glut.h>
#include<stdio.h>
#include <stdlib.h>
#include <math.h>
/*Initial set up */
void init (void)
{
glClearColor (1.0, 1.0, 1.0, 0.0); // Set
display-//window color to white.
glMatrixMode (GL_PROJECTION); //
Set //projection parameters.
gluOrtho2D (0.0, 200.0, 0.0, 150.0);
}
/*Creating a line*/
• void lineSegment (void)
• {
• glClear (GL_COLOR_BUFFER_BIT); // Clear display
window.
• glColor3f (1.0, 0.0, 0.0); // Set line segment color to red.
• glBegin (GL_LINES);
• glVertex2i (180, 15); // Specify line-segment geometry.
• glVertex2i (10, 145);
• glEnd ( );
• glFlush ( ); // Process all OpenGL routines as quickly
as possible.
• }
/*The main function*/
• void main (int argc, char** argv)
• {
• glutInit (&argc, argv); // Initialize GLUT.
• glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); // Set display
mode.
• glutInitWindowPosition (50, 100); // Set top-left display-window
position.
• glutInitWindowSize (400, 300); // Set display-window width and
height.
• glutCreateWindow ("An Example OpenGL Program"); // Create
display window.
• init ( ); // Execute initialization procedure.
• glutDisplayFunc (lineSegment); // Send graphics to display window.
• glutMainLoop ( ); // Display everything and wait.
• }
/*More procedures*/
• void line_segment(void)
• {
• glClear(GL_COLOR_BUFFER_BIT);
• glColor3f(0.0,0.0,1.0);
• glBegin(GL_LINE_STRIP);
• glVertex2i(180,15);
• glVertex2i(10,145);
• glVertex2i(100,15);
• glVertex2i(10,185);
• glEnd();
• glFlush();
• }
Cont…
• void line_segment(void)
• {
• glClear(GL_COLOR_BUFFER_BIT);
• glColor3f(0.0,0.0,1.0);
• glBegin(GL_LINE_LOOP);
• glVertex2i(180,15);
• glVertex2i(10,145);
• glVertex2i(100,15);
• glVertex2i(10,185);
• glEnd();
• glFlush();
• }
OpenGL Example
Here’s an example that renders a colored triangle (Note
that this doesn’t include any ‘setup’ code)
glBegin(GL_TRIANGLES);
glColor3f(1.0, 0.0, 0.0); // red
glVertex3f(-4.0, -2.0, 0.0);
glColor3f(0.0, 1.0, 0.0); // green
glVertex3f(4.0, -2.0, 0.0);
glColor3f(0.0, 0.0, 1.0); // blue
glVertex3f(0.0, 5.0, 0.0);
glEnd();
