Chapter 3

Introduction to the Rendering

Process with OpenGL
3.1. The Role of OpenGL in the Reference Model
3.2. Coordinate Systems
3.3. Viewing Using a Synthetic Camera
3.4. Output Primitives and Attributes
Introduction to the Rendering Process with OpenGL
• The rendering process is the series of steps that are taken to
generate an image or a video from a model or a scene using
computer graphics techniques
• It is a series of steps that converts a 3D scene into a 2D
image.
• The rendering process involves several key concepts,
including coordinate systems, synthetic camera, and output
primitives, to create and manipulate 3D graphics in
applications.
• OpenGL (Open Graphics Library) is a cross-platform
application programming interface (API) for rendering 2D
and 3D vector graphics.
• OpenGL serves as a critical component in the graphics
rendering pipeline.
• OpenGL is a powerful API that provides a standardized
interface for interacting with the graphics pipeline.
• It allows developers to control various stages of the pipeline,
enabling them to create rich and interactive graphics.
Rendering Pipeline Tasks
• 3D input tasks:
• a virtual camera
• position, orientation, focal length
• objects
• points (vertex / vertices), lines, polygons
• geometry and material properties (position, normal, color,
texture coordinates)
• light sources
• direction, position, color, intensity
• textures (images)
• 2D output
• per-pixel color values in the framebuffer
• Some Rendering Pipeline Functionality
• resolving visibility
• evaluating a lighting model
• computing shadows (not core functionality)
• applying textures
• 3D graphics Rendering pipeline:
• output of one stage is fed as input of the next
stage.
• A vertex has attributes such as (x,y,z) position,
color(RGB or RGBA), vertex-normal (nx,ny,nz),
and texture.
• A primitive is made up of one or more vertices.
• The rasterizer raster scans each primitive to
produce a set of grid-aligned fragments, by
interpolating the vertices
1.Vertex Processing: Process and transform individual
vertices & normals.
2. Rasterization: Convert each primitive (connected
vertices) into a set of fragments.
A fragment can be interpreted as a pixel with
attributes such as position, color, normal and texture.
3.Fragment Processing: Process individual fragments.
4. Output Merging: Combine the fragments of all
primitives (in 3D space) into 2D color-pixel for the
display.
OpenGL rendering pipeline:
• It is a series of processing stages from vertex data to
display
• Most implementation of OpenGL have a similar
order of operations, a series of processing stages
called the Open GL rendering pipeline.
• It is not a strict rule of how OpenGL is implemented
but provides a reliable guide for predicting what
OpenGL will do.
Stages in Rendering Process
• Vertex data: Data for geometric objects consist of vertices
• Per-vertex operations: Translations and rotations are performed
for some vertices.
• Positions in the 3D world are projected onto positions on the screen.
• Lighting calculations are performed using the vertices, surface normal,
light sources, and material properties.
• Primitive assembly: Clipping eliminates portions of geometry,
which fall outside the screen.
• Rasterizations: Conversion of geometric data into fragments.
• Each fragment square corresponds to a pixel in the framebuffer.
• Color and depth (z coordinate) values are assigned.
• Per-fragment operations: Hidden surface removal using the depth
buffer (z buffer) or alpha blending for transparent materials.
• Framebuffer: A collection of buffers that store data for screen
pixels (screen is, for example, 1024 pixels wide and 1024 pixels
high) such as color, depth information for hidden surface removal,
etc.
3.1. The Role of OpenGL in the Reference Model
• It is widely used in the development of computer graphics
applications, including video games, CAD software, and virtual
reality systems.
• In the graphics rendering pipeline, OpenGL plays a crucial role in
the transformation, lighting, and rasterization stages.
• OpenGL plays a crucial role in the reference model, primarily in the
geometry and rasterization stages
• Graphics Pipeline: OpenGL follows a graphics pipeline model
which includes stages such as vertex processing, primitive
assembly, rasterization, fragment processing, and output merging.
• API for Graphics: OpenGL provides functions to manage the
graphics pipeline, allowing developers to specify how objects are
rendered.
• Cross-Platform Support: OpenGL is designed to work on various
operating systems, making it a versatile choice for developers.
• Hardware Acceleration: Leverages the GPU for efficient rendering,
enhancing performance compared to CPU-only rendering.
What Is OpenGL?
▪ OpenGL is a computer graphics rendering API
• can generate high-quality color images by rendering with
geometric and image primitives
• It forms the basis of many interactive applications that include
3D graphics
• It is operating system and windows system independent
• It Provide a standard specification defining a cross-platform
API for writing applications that produce 3D computer
graphics (and 2D computer graphics as well).
• A low-level graphics rendering and imaging library
• only includes operations which can be accelerated
• Does not include low-level I/O management
• Basis for higher-level libraries/toolkits, GLU, GLUT
• OpenGL provides a standard implementation for graphics
pipeline and scan conversion algorithms for fundamental
primitives.
Features of OpenGL:
• It is a platform-independent API that is
• 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 does the rendering pipeline:
• Transform geometry (object ->world ->eye->device->
frame buffer)
• Calculate surface lighting
• Apply perspective projection (eye ->screen)
• Clip
• Perform visible-surface processing
• Scan conversion/rasterization of primitives
• Core functions/routines, for transformation, and
rasterization for primitives for 2D/3D graphics, and many
others.
The common OpenGL functionalities:
• Texture Mapping:
• is the ability to apply an image to graphics surface
• used to rapidly generate realistic images without having to
specify an excessive amount of detail
• ie. create a wooden floor by painting the floor’s rectangular
surface with a wood grain texture.
• Z-buffering:
• is the ability to calculate the distance from the viewer’s
location
• make it easy for the program to automatically remove
surfaces or parts of surface that are hidden from view
• At the start, enable the Z-buffer:
• glEnable(GL_DEPTH_TEST);
• Before each drawing, clear the Z-buffer:
• glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
• Double buffering:
• support for smooth animation using double
buffering
• drawing into the back buffer while displaying
the front buffer and then swapping the buffers
when you are ready to display.
• Enable double-buffering:
• auxInitDisplayMode (AUX_DOUBLE | ....);
• Your drawing is done in the hidden buffer
• After drawing, swap buffers:
• auxSwapBuffers();
• Double buffer = half the color bits.
• 4 bits (=16 colors) on a 8 bit display…
• Lighting effects:
• is the ability to calculate the effects on the
lightness of a surface’s color when different
lighting models are applied to the surface from
one or more light
• Three steps:
• Enable lighting
• Specify the lights
• Specify the materials
• Advanced user:
• local/infinite viewpoint
• two sided lighting
• Smooth shading:
• is the ability to calculate the shading effects that occur
when light hits a surface at an angle and results in subtle
color differences across the surface
• this effect is important for making a model look
“realistic”
• Material Properties:
• is the ability to specify the material properties of a surface
• dullness
• Shininess
• Alpha Blending:
• is the ability to specify an alpha or “opacity” value in
addition to regular RGB value
• Transformation Matrices:
• is the ability to change the location, size and perspective of
an object in 3D coordinate space
• Limitation of OpenGL:
Microsoft Generic implementation of OpenGL
• no direct support for printing OpenGL graphics to a
monochrome printer or a color printer with less
than 4 bit planes of color
• hardware palettes for various windows are not
supported
• some OpenGL features are not implemented,
including stereoscopic images, auxiliary buffers,
and alpha bit planes.
• How OpenGL works:
• the same way that GDI ( Graphics Device Interface)
work
• whenever a program makes an OpenGL call, the
OPENGL32 and GLU32 DLLs are loaded.
❖OpenGL API OpenGL API

Applicaton

Applicaton Graphics Package

OpenGL Application Programming Interface

Hardware and software

Output Device Input Device Input Device

17
OpenGL Libraries
• OpenGL core library
• OpenGL32 on Windows
• GL on most unix/linux systems
• OpenGL Utility Library (GLU)
• Provides functionality in OpenGL core but avoids having
to rewrite code
• It uses only GL functions to create common objects.
• It is available in all OpenGL implementations.
• OpenGL Utility Toolkit (GLUT)
• It provides the minimum functionalities expected for
interacting with modern windowing systems.
• Links with window system
• GLX for X window systems
• WGL for Windows
• AGL for Macintosh
• OpenGL utility library (GLU)
– It consists of a number of functions that use the base
OpenGL library to provide higher-level drawing routines
from the more primitive routines that OpenGL provides.
– It is usually distributed with the base OpenGL package
– Functions in GLU are basically built up by routines from
GL
• Features of GLU includes:
• Setting up viewing and projection
• Describing complex objects with line and polygon
approximation
• Display quadrics and B-splines using approximation
• It also provides additional primitives for use in
OpenGL applications, including spheres, cylinders
and disks
• Generally in more human-friendly terms than the
routines presented by OpenGL.
• OpenGL Utility Toolkit (GLUT):
• A library of utilities for OpenGL programs, which primarily perform system-
level I/O with the host operating system.
• Functions performed include window definition, window control, and
monitoring of keyboard and mouse input: including setting up windows,
window size, position, keyboard, mouse, etc.
• Functions with prefix: glut, see glut reference
• Provides functionality common to all window systems
• Open a window, Initialize OpenGL State
• Get input from mouse and keyboard
• Menus and Event-driven
• Code is portable but GLUT lacks the functionality of a good toolkit for a
specific platform
• Features:
• Routines for drawing a number of geometric primitives (both in solid and
wireframe mode), including cubes, spheres, and the teapot
• GLUT has some limited support for creating pop-up menus
• Note that there special extension for each platform
• GLX for X window system
• Apple GL (AGL)
• WGL (Windows-to-OpenGL)
• GLUI is a GLUT-based C++ user interface library
(was written by Paul Rademacher)
• It provides controls such as buttons, checkboxes, radio
buttons, and spinners to OpenGL applications
• It is window- and operating system independent, relying
on GLUT to handle all system-dependent issues, such as
window and mouse management
• GLUI can be installed by updating from Dev-C++
• Functions in OpenGL start with gl
• Most functions just gl (e.g., glColor())
• Functions starting with glu are utility functions (e.g.,
gluLookAt())
• Functions starting with glx are for interfacing with the X
Windows system (e.g., in gfx.c)
 OpenGL API
OpenGL API Library Organization

GLX for X window systems

WGL for Windows
AGL for Macintosh
22
 OpenGL API
❖OpenGL API Program Structure
▪ Step 1: Initialize the interaction between
windows and OpenGL.
▪ Step 2: Specify the window properties and further
create window.
▪ Step 3: Set the callback functions
▪ Step 4: Initialize the program attributes
▪ Step 5: Start to run the program

23
 OpenGL API
❖Program Framework: Window Management
▪ glutInit():initializes GLUT and should be
called before any other GLUT routine.
▪ glutInitDisplayMode():specifies the
color model (RGB or color-index color model)
▪ glutInitWindowSize(): specifies the size,
in pixels, of your window.
▪ glutInitWindowPosition():specifies the
screen location for the upper-left corner
▪ glutCreateWindow():creates a window
with an OpenGL context.
24
 OpenGL API
❖Program Framework: Color Manipulation
▪ glClearColor():establishes what color the
window will be cleared to.
▪ glClear():actually clears the window.
▪ glColor3f():establishes what color to use
for drawing objects.
▪ glFlush():ensures that the drawing
command are actually executed.
Remark: OpenGL is a state machine. You put it into various
states or modes that remain in effect until you change them

25
GLUT functions:
glutInit( ) :
• It allows application to get command line arguments
and initializes system
• The arguments allows application to get command
line arguments (argc and argv) and initializes system
• This procedure must be called before any others.
• It processes (and removes) command-line arguments
that may be of interest to GLUT and the window
system and does general initialization of GLUT and
OpenGL.
glutInitDisplayMode( ):
• This function performs initializations informing
OpenGL how to set up its frame buffer.
• It requests properties of the window (the rendering
context)
• RGB color
• Single buffering
• Properties logically ordered together
• The argument to glutInitDisplayMode() is a logical-OR (using
the operator “|”) of a number of possible options, which are
given in Table
• glutInitWindowSize( ):
• This command specifies the desired width and height of
the graphics window. The general form is:
glutInitWindowSize(int width, int height)
• The values are given in numbers of pixels.
• glutInitPosition( ):
• This command specifies the location of the upper left
corner of the graphics window. The form is
glutInitWindowPosition(int x, int y)
• where the (x, y) coordinates are given relative to the
upper left corner of the display. Thus, the arguments
(0, 0) places the window in the upper left corner of the
display.
• glutCreateWindow( ):
• This command actually creates the graphics
window.
• The general form of the command is
glutCreateWindowchar(*title)
• where title is a character string. Each window
has a title, and the argument is a string which
specifies the window’s title.
• glutDisplayFunc( ) display callback
• glutMainLoop( ) enter infinite event loop
 OpenGL Program Structure
Basic program structure of C/C++ with function call to OpenGL
functions includes:
• Header files
• Global variables and data structures for controls and modeling
• Self-defined functions (C/C++, gl, glu, glui, function calls are
involved)
• Main function (glut functions calls are involved)

• Header files:
• Header files include necessary libraries and declarations needed for an
OpenGL program:
• OpenGL Libraries: Include standard OpenGL libraries such as
GL/gl.h or GL/glut.h for basic OpenGL functionality.
• GLU (OpenGL Utility Library): Include GL/glu.h for utility
functions that simplify tasks, such as setting up projections.
• GLUT (OpenGL Utility Toolkit): Include GL/glut.h for window
management and handling user input.
• Additional Libraries: You might include other libraries depending
on your needs, such as #include <math> for mathematical functions
and stdio.h,stdlib.h,etc.
Header files can be used in the OpenGL program as
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <GL/glui.h> // if GLUI is installed

• If glut.h is included, no need to include gl.h and

glu.h
• Libraries links (on Windows platform) for the
project
-|opengl32, -|glu32, -|glut32, -|winmm
• May include other C/C++ headers, such as
stdio.h, stdlib.h, math.h, etc.
• Global variables and data structures help manage the state
of your OpenGL program:
• Window Dimensions: Variables to store the width and height of
the window.
• Model Data: Arrays or structures that hold the vertices, colors,
and other attributes of the 3D models.
• Transformation Matrices: Variables to keep track of
transformations (translation, rotation, scaling).
• State Variables: Flags to manage the state of the application
(e.g., whether lighting is enabled).
• Self-defined Functions:
• These functions encapsulate specific tasks in your OpenGL
program:
• Initialization Functions: Functions to set up the rendering
context, load textures, or initialize shaders.
• Rendering Functions: Functions that contain the drawing logic,
typically called within the display loop.
• Input Handling: Functions to handle keyboard and mouse input,
often using callbacks.
• Main Function:
• The main function is the entry point of the program
and contains GLUT function calls to set up the
window, register callbacks, and start the rendering
loop:
• glutInit: Initializes the GLUT library.
• glutCreateWindow: Creates the window with
specified dimensions and title.
• glutDisplayFunc: Registers the display callback
function.
• glutMainLoop: Enters the GLUT event
processing loop.
Example : void reshape(int w, int h) {
// Update viewport and projection matrix
#include <GL/gl.h> glViewport(0, 0, w, h);
#include <GLUT/glut.h> glMatrixMode(GL_PROJECTION);
// Global variables and data structures glLoadIdentity();
float rotationAngle = 0.0f; gluPerspective(60.0f, (float)w / h, 1.0f, 100.0f);
float vertices[] = { /* vertex data */ }; }
// Self-defined functions void keyboard(unsigned char key, int x, int y) {
// Handle keyboard input
void init() {
if (key == 'q') {
// Initialize OpenGL context and load
exit(0);
resources
}
}
}
void display() {
// Main function
// Render the 3D scene
int main(int argc, char** argv) {
glClear(GL_COLOR_BUFFER_BIT |
glutInit(&argc, argv);
GL_DEPTH_BUFFER_BIT);
glutInitDisplayMode(GLUT_DOUBLE |
glMatrixMode(GL_MODELVIEW);
GLUT_RGB | GLUT_DEPTH);
glLoadIdentity(); glutInitWindowSize(640, 480);
glRotatef(rotationAngle, 0.0f, 1.0f, 0.0f); glutCreateWindow("OpenGL Program");
// Draw geometry using vertex data glutDisplayFunc(display);
glutSwapBuffers(); glutReshapeFunc(reshape);
} glutKeyboardFunc(keyboard);
init();
glutMainLoop();
return 0;
}
• Most OpenGL programs have a similar structure that
consists of the following functions
• main( ):
• defines the callback functions
• opens one or more windows with the required
properties
• enters event loop (last executable statement)
• init( ): sets the state variables
• viewing
• Attributes
• callbacks
• Display function
• Input and window functions
main( ) function:
• Main( ) includes glut functions to
perform the following activities:
1. GLUT initialization
2. Create a window and attach OpenGL to it
3. Set camera parameters
• Setup lighting, if any
4. Register callback functions
• Key press, mouse movement, screen resize
5. Main rendering loop
• OpenGL controls execution from this point
forward
1. GLUT initialization
• glutInit(&argc, argv);
• argc and argv potentially used by glutInit and preserved
• glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE );
• Red, green, blue, and alpha (transparency), double buffer,
and depth buffered
• glutInitWindowSize(400, 300);//default 400 by 300
• glutInitWindowPosition(50, 100);
2. Create a window
glutCreateWindow(“An example of OpenGL
grogram”);
3. Setup camera (Define viewport, project,
matrixmode (defined in init( ) )
Set to clear window color
glClearColor (1.0, 1.0, 1.0, 0.0);
// Set display-window view mode.
glMatrixMode (GL_PROJECTION);
// Set projection parameters.
gluOrtho2D (0.0, 200.0, 0.0, 150.0);
• More
glViewport(0, 0, width, height);
• Viewport is the portion of the window on the
project plane you want to render
4. Register callback functions
▪ it is executed upon interrupt caused by user or by OpenGL main
loop
glutDisplayFunc(lineSegment);
lineSegment( ) does the rendering, send graphics to display window, redisplay
• More register funcitons
glutReshapeFunc(resize_scene);
resize_screen() is executed upon startup and upon window resize
glutKeyboardFunc(key_press);
key_press() is executed when a key is pressed
glutMouseFunc(handle_mouse_click);
handle_mouse_click() is executed when a mouse button pressed
glutMotionFunc(mouse_motion);
mouse_motion() is executed when key clicked and mouse moved
5. Initiate main rendering loop
glutMainLoop();
Your program never regains explicit control
OpenGL State:
• OpenGL State refers to the various settings and configurations that affect
how OpenGL renders graphics. These states can include settings for
colors, textures, lighting, blending, depth testing, and more.
• OpenGL state functions are of two types
• Primitive generating
• Can cause output if primitive is visible
• How vertices are processes and appearance of primitive are controlled
by the state
• State changing
• Transformation functions
• Attribute functions
• OpenGL #defines:
• to represent specific values or constants. These #defines can be used in
OpenGL function calls, enumerations, and other places where specific values
are required.
• Most constants are defined in the include files gl.h, glu.h and glut.h
• Note #include <glut.h> should automatically include the others
• Examples: glBegin(GL_PLOYGON)
glClear(GL_COLOR_BUFFER_BIT)
• include files also define OpenGL data types: Glfloat, Gldouble,….
• Event Loop:
• it is responsible for managing the application's main control flow and
handling user input events.
• The event loop is typically implemented using a library such as
GLUT (OpenGL Utility Toolkit)
• 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
• Defaults:
• preset value by system or program itself
• ensure that OpenGL has a consistent starting point for rendering
graphics.
• it allows you to know the initial state of the rendering pipeline and
make appropriate changes as needed.
• Makes heavy use of state variable default values for
• Viewing
• Colors
• Window parameters
❖Program Framework Example:

#include <GL/glut.h> includes gl.h

int main(int argc, char** argv)

{
interaction initialization
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("simple"); define window properties

glutDisplayFunc(myDisplay);
display callback
myInit(); set OpenGL state

glutMainLoop(); enter event loop

}
42
 OpenGL
❖Program Framework API
example

void myInit(){
/* set colors */
glClearColor(1.0, 1.0, 1.0, 0.0);
}/* End of myInit */

void myDisplay(){
/* clear the display */
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}/* End of GasketDisplay */

43
Example: init.c

black clear color

void init()
{ opaque window
glClearColor (0.0, 0.0, 0.0, 1.0);

glColor3f(1.0, 1.0, 1.0); fill with white

glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}
viewing volume

44
#include <GL/glut.h>

int main(int argc, char** argv)

{ includes gl.h
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(0,0);
glutCreateWindow("simple");
glutDisplayFunc(mydisplay); define window properties

init(); set OpenGL state display callback

glutMainLoop();
} enter event loop
• A Simple Program: Generate a square on a solid
background
#include <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();
OpenGL Functions:
▪ OpenGL Primitives and attributes
▪ Points
▪ Line Segments
▪ Polygons
▪ Transformations
▪ Viewing
▪ Modeling
▪ Control
▪ Input (GLUT)
• OpenGL Primitives:
• the basic building blocks in OpenGL for rendering 2D and 3D shapes.
• The types of primitives includes: points , line segments and polygons.
• Points:
Syntax:
glBegin(GL_POINTS);
glVertex3f(x, y, z);
glEnd();
Example: glBegin(GL_POINTS);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 1.0f);
glEnd();
• Line Segments:
Syntax:
glBegin(GL_LINES);
glVertex3f(x1, y1, z1);
glVertex3f(x2, y2, z2);
glEnd();
Example:glBegin(GL_LINES);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 1.0f);
glEnd();
• Attributes:
• It is any property that determines how a geometric primitive is to be
rendered.
• Each geometric primitive has a set of attributes.
• Point: Color
• Line Segments: Color, Thickness, and Pattern
• Polygon: Pattern
• It controls the appearance and behavior of the primitives, such as
color, lighting, texture, and material properties.
• Syntax :
• glColor3f(r, g, b); sets the current color.
• glNormal3f(nx, ny, nz); sets the current normal vector.
• glTexCoord2f(s, t); sets the current texture coordinates.
• Example:
• glColor3f(1.0f, 0.0f, 0.0f); // set color to red
• glBegin(GL_TRIANGLES);
• glVertex2f(-10.0f, -10.0f);
• glVertex2f(10.0f, -10.0f);
• glVertex2f(0.0f, 10.0f);
• glEnd();
OpenGL Transformations:
• The process of manipulating the position, orientation, and scale of
the objects in the 3D world.
• It includes viewing and modeling transformation
• Viewing Transformations:
• used for setting up the camera and view-related
transformations in the 3D world.
• Syntax:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fov, aspect, near, far);
gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ,
upX, upY, upZ); sets the camera position and orientation.
gluLookAt(0.0f, 0.0f, 5.0f, // Eye position
0.0f, 0.0f, 0.0f, // Look at point
0.0f, 1.0f, 0.0f); // Up vector
• Modeling Transformations :
• applying transformations (translation, rotation, scaling) to the
objects in the scene.
• manipulating the position, orientation, and scale of the objects
in the 3D world.
• Syntax:
• glMatrixMode(GL_MODELVIEW);
• glLoadIdentity();
• glTranslatef(x, y, z); // applies a translation transformation
• glRotatef(angle, x, y, z); // applies a rotation transformation
• glScalef(x, y, z); // applies a scaling transformation
Example: glTranslatef(1.0f, 0.0f, 0.0f); // Move right by 1 unit
glRotatef(45.0f, 0.0f, 1.0f, 0.0f); // Rotate 45 degrees
around y-axis
OpenGL Control functions :
• OpenGL provides various control functions to manage the
rendering process, such as clearing the color and depth buffers,
enabling and disabling features, and more.
• Syntax:
• glEnable(GL_DEPTH_TEST); enables depth testing for hidden
surface removal.
• glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT); clears the color and depth buffers.
• glDisable(GL_CULL_FACE); // disable face culling
• glFlush(); forces all issued commands to be executed as soon as
possible.
OpenG LInput (GLUT):
• It provides a simple way to handle user input and create
OpenGL windows.
• Syntax:
• glutInit(&argc, argv); initializes GLUT.
• glutCreateWindow("Window Title"); creates a window.
• glutDisplayFunc(display_callback); sets the display callback
function.
• glutMainLoop(); enters the main event processing loop.
3.2. Coordinate Systems
• Coordinate systems are a fundamental concept in computer
graphics and are used to define the position and orientation of
objects in 3D space.
• In OpenGL, coordinate systems are used to specify the
position, orientation, and scale of objects, lights, and cameras.
• Understanding coordinate systems is essential for creating 3D
graphics with OpenGL.
• To define positions of points in space one requires a
coordinate system. It is way of determining the position of a
point by defining a set of numbers called as coordinates.
• The most common coordinate systems used in OpenGL are:
• Model Coordinate System
• World Coordinate System
• View Coordinate System
• Clip Coordinate System
• Screen Coordinate System
• Model Coordinates:
• These are the coordinates defined by the application to
describe the geometry of an object.
• It is also known as Object Coordinates or local Coordinates
• The origin and orientation of object coordinates are defined
by the application.
• There are no built-in OpenGL functions to manipulate object
coordinates.
• World Coordinates:
• the coordinates used to define the position and orientation of
objects in the scene.
• It is also known as the user’s coordinate system
• A world-coordinate area selected for display is called a
window (defines what is to be viewed).
• It can be transformed into camera coordinates using the
modelview matrix.
• The function glLoadIdentity() sets the modelview matrix to
the identity matrix, and glMultMatrixd() multiplies the
current matrix by a given matrix.
• View Coordinate /Camera Coordinates:
• the coordinates used to define the position and orientation
of the camera.
• It can be transformed into screen coordinates using the
projection matrix.
• The function gluPerspective() sets up a perspective
projection matrix, and glFrustum() sets up a frustum
projection matrix.
• Clip Coordinate System:
• Defines the coordinate after the camera's viewing frustum
is applied.
• The viewing frustum is the 3D volume that defines what is
visible to the camera.
• Objects outside the viewing frustum are clipped and not
rendered.
• Coordinates are transformed from the view coordinate
system to the clip coordinate system.
• Screen Coordinates:
• Defines the 2D coordinate system of the final rendered image
on the screen.
• It can be transformed from the clip coordinate system to the
screen coordinate system for rendering.
• An area on a display device to which a window is mapped is
called a viewport (defines where it is to be displayed).
• Often, windows and viewports are rectangles in standard
position, with the rectangle edges parallel to the coordinate
axes.
• The actual coordinate system on the output device.
• The graphics system is responsible to map the user’s coordinate
to the screen coordinate.
• It ranges from -1 to 1 in both the x and y directions.
• The function glViewport() sets up the screen coordinates.
• Homogeneous Coordinates:
• OpenGL uses homogeneous coordinates for transformations,
which allows for easy representation of translation with matrix
multiplication.
• A 3D point (𝑥,𝑦,𝑧) is represented as (𝑥,𝑦,𝑧,𝑤) where 𝑤 typically
equals 1.
OpenGL Functions for Coordinate System Management
• glTranslatef(): Applies a translation transformation.
• glRotatef(): Applies a rotation transformation.
• glScalef(): Applies a scaling transformation.
• glLoadIdentity(): Resets the current matrix to the
identity matrix.
• glMatrixMode(): Selects which matrix stack to
manipulate (model, view, projection).
• gluPerspective(): Defines a perspective projection
matrix.
• glViewport(): Sets the viewport dimensions.
• Example:
• glMatrixMode(GL_MODELVIEW);
• glLoadIdentity();
• glTranslated(0, 0, -10); //move the camera 10 units away from the
origin
• glMatrixMode(GL_PROJECTION);
• glLoadIdentity();
• glFrustum(-1, 1, -1, 1, 1, 100); // set up a frustum projection
matrix
• glViewport(0, 0, 500, 500); // set up the screen coordinates
• // Set camera position and orientation
gluLookAt(0.0, 0.0, 5.0, // Camera position
0.0, 0.0, 0.0, // Look-at point
0.0, 1.0, 0.0); // Up vector
• glTranslatef(1.0f, 0.0f, 0.0f); moves the object 1 unit along the x-axis.
• glRotatef(90.0f, 0.0f, 1.0f, 0.0f); rotates the object 90 degrees around
the y-axis.
• glScalef(2.0f, 1.0f, 1.0f); doubles the object's size along the x-axis
3.3. Viewing Using a Synthetic Camera
• In OpenGL, we can use a synthetic camera to control the
viewing of a scene.
• A synthetic camera is a virtual camera that allows us to specify
the position, orientation, and other parameters of a camera in a
3D scene.
• The Viewing Pipeline:
• It is the process of transforming 3D objects in a scene into 2D
images on the screen.
• The pipeline consists of several stages:
• Modeling: Defining the 3D objects in the scene.
• Viewing: Specifying the camera's position, orientation, and
other parameters.
• Projection: Transforming the 3D objects into 2D images
using a projection matrix.
• Clipping: Discarding objects outside the view volume.
• Rendering: Drawing the 2D images on the screen.
 Viewing: Camera Analogy

Positioning the Camera Viewing Transformation

Positioning the Model Modeling Transformation

Choose a camera lens

Projection Transformation
and adjust zoom

Mapping to screen Viewport Transformation

• The mapping of a part of a world-coordinate
scene to device coordinates is referred to as a
viewing transformation.
• 2D viewing transformation is simply referred to
as the window-to-viewport transformation or
the windowing transformation.
The viewing transformation is carry out in several steps,
as shown in the figure.

• Construct the scene in world coordinate (WC) using

the output primitives such as line and circle and their
attributes.
• Obtain a particular orientation for the window, set up a
two-dimensional viewing coordinate (VC) system in the
world coordinate plane, and define a window in the
viewing coordinate system.
62
• The viewing – coordinate reference frame is
used to provide a method for setting up
arbitrary orientations for rectangular windows.
• Once the viewing reference frame is
established, we can transform descriptions in
world coordinates (WC) to viewing
coordinates (VC).
• We then define a viewport in normalized
coordinates (NVC) (in the range from 0 to 1)
and map the viewing – coordinate description
of the scene to normalized– coordinate.
63
At the final step, all parts of the picture that lie outside
the viewport are clipped, and the contents of the viewport
are transferred to device coordinates (DC).

A rotated viewing-coordinate reference frame and the

mapping to normalized coordinates.

64
• By changing the position of the window, we can view
objects at different positions on the display area of an
output device.
• By varying the size of viewports, we can change the
size and proportions of the displayed objects. We
achieve zooming effects by successively mapping
different-sized windows on a fixed-size viewport.
• As the windows are made smaller, we zoom in on
some part of a scene to view details that are not
shown with larger windows.
• Similarly, more overview is obtained by zooming out
from a section of a scene with successively larger
windows. 65
• Viewports are typically defined within the unit square
(normalized coordinates).
• This provides a means for separating the viewing and
other transformations from specific output-device
requirements, so that the graphics package is largely
device-independent.
• Once the scene has been transferred to normalized
coordinates, the unit square is simply mapped to the
display area for the particular output device in use at
that time.
• Different output devices can be used by providing the
appreciate device derivers.
66
• In OpenGL, the camera is modeled as a synthetic camera with the
following parameters:
• Eye position (ex, ey, ez): The location of the camera in 3D space.
• Look-at point (lx, ly, lz): The point the camera is looking at.
• Up vector (ux, uy, uz): The direction of the camera's up vector.
• These parameters define the camera's orientation and position in 3D
space.
• OpenGL Functions for Viewing:
• glMatrixMode(GL_PROJECTION): Specifies the projection matrix.
• glMatrixMode(GL_MODELVIEW): Specifies the modelview matrix.
• glLoadIdentity(): Loads the identity matrix into the current matrix.
• gluLookAt(): Sets up a viewing matrix based on the camera's
parameters.
• gluPerspective(): Sets up a perspective projection matrix.
• Example Code: to set up a synthetic camera using OpenGL
• glMatrixMode(GL_PROJECTION);
• glLoadIdentity();
• gluPerspective(45, aspectRatio, 1, 100);
• glMatrixMode(GL_MODELVIEW);
• glLoadIdentity();
• gluLookAt(ex, ey, ez, lx, ly, lz, ux, uy, uz);
• In OpenGL, the viewer or "camera" is simulated using a
transformation matrix called the Modelview matrix.
• This matrix defines the position and orientation of the camera in the
WCS.
• In OpenGL, the viewing transformation is used to simulate a camera's
viewpoint.
• The camera's position, orientation, and field of view are specified
using the following functions:
• glLoadIdentity( ); Resets the Modelview matrix to the identity matrix.
• glTranslatef(x, y, z); Translates the Modelview matrix by (x, y, z).
• glRotatef(angle, x, y, z); Rotates the Modelview matrix by angle degrees
around the vector (x, y, z).
• glMultMatrixf(matrix); Multiplies the current Modelview matrix by the
4x4 matrix specified by matrix.
• gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY,
upZ); gluLookAt( ) is commonly used to set up the camera.
• Example: gluLookAt(0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
• This sets up a viewing transformation simulating a camera located at (0,
0, 10) looking towards the origin (0, 0, 0) with the up direction (0, 1, 0).
• In OpenGL, we can define a synthetic camera to control
the viewpoint and orientation of the scene.
• The function gluLookAt() is commonly used to set up
the camera.
• It takes three arguments for each of the eye, center, and
up vectors.
• The eye vector specifies the position of the camera, the
center vector specifies the point the camera is looking
at, and the up vector specifies the orientation of the
camera.
• Example:
• glMatrixMode(GL_MODELVIEW);
• glLoadIdentity();
• gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0);
• set up the camera at (0, 0, 10), looking at (0, 0, 0), with up
vector (0, 1, 0)
• This camera has several properties that determine what is visible
in the scene:
• Position: The camera's location in world coordinates.
• Orientation: The camera's direction of view and its "up" direction.
• Projection: The way the 3D world is projected onto the 2D screen.
• Functions:
• gluLookAt(): Sets the camera position, orientation, and look-at point.
• gluPerspective(): Creates a perspective projection, simulating a real
camera lens.
• glOrtho(): Creates an orthographic projection, where objects are projected
without perspective.
• Examples:
• Setting the camera: gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0,
1.0, 0.0); places the camera at (0, 0, 5) and points it towards the
origin.
• Perspective projection: gluPerspective(45.0f, 1.0f, 0.1f, 100.0f);
creates a perspective projection with a 45-degree field of view.
• Orthographic projection: glOrtho(-5.0f, 5.0f, -5.0f, 5.0f, 0.1f,
100.0f); creates an orthographic projection with a view volume of
10x10 units.
Two- and three-dimensional viewing
• In glOrtho(left, right, bottom, top, near, far) the near and far
distances are measured from the camera
• Two-dimensional vertex commands place all vertices in the plane z=0
• If the application is in 2D or 3D, we can use the function
gluOrtho2D(left, right,bottom,top)
gluOrtho3D(left, right,bottom,top)
Example:
glBegin(GL_POLYGON);
glVertex2f(-0.5, -0.5);
glVertex2f(-0.5, 0.5);
glVertex2f(0.5, 0.5);
glVertex2f(0.5, -0.5);
glEnd();
glBegin(GL_LINE_STRIP)
glVertex3f(0.0f, 0.0f, 0.0f); // v0
glVertex3f(50.0f, 50.0f, 0.0f); // v1
glVertex3f(50.0f, 100.0f, 0.0f); // v2
glEnd(); 71
3.4. Output Primitives and Attributes in OpenGL
• Output primitives are the basic shapes rendered in OpenGL
geometry.
• OpenGL supports several types of output primitives, such as
points, lines, and triangles.
• These primitives can be specified using various functions and
attributes.
• These primitives are :
• Points: The simplest primitive, represented by a single
vertex.
• Lines: A sequence of connected vertices, forming a straight
line.
• Triangles: A three-vertex polygon, the most common
primitive for 3D models.
• Polygons: A closed shape defined by multiple vertices.
• Circles, character strings and so on.
• Functions and its syntax:
• glBegin(mode); Begins the specification of a set of vertices that
define a primitive of the specified mode.
• glVertex*(): Specifies the coordinates of a vertex.
• glVertex3f(x, y, z); Specifies a 3D coordinate (x, y, z) for the
current vertex.
• glEnd(); Ends the specification of a set of vertices for a primitive.
Examples: Drawing a triangle: draws a triangle with vertices at (0,
0, 0), (1, 0, 0), and (0, 1, 0).
glBegin(GL_TRIANGLES);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 0.0f);
glEnd();
Setting color: glColor3f(1.0f, 0.0f, 0.0f); sets the color of the next
primitive to red.
• Applying texture: glTexCoord2f(0.0f, 0.0f); sets the texture
coordinates for the current vertex to (0, 0).
• Attributes:
• It defines the features and appearances of primitives
• These includes:.
• Color: specified using the function glColor3f(red, green, blue).
• Normal: specified using the function glNormal3f(x, y, z).
• Texture Coordinate: specified using the function glTexCoord2f(s, t).
• Syntax: glColor3f(red, green, blue)
glNormal3f(x, y, z);
glTexCoord2f(s, t);
• Example:
• glBegin(GL_TRIANGLES);
• glColor3f(1, 0, 0); // set the color to red
• glVertex3f(0, 0, 0); // define the first vertex of the triangle
• glColor3f(0, 1, 0); // set the color to green
• glVertex3f(1, 0, 0); // define the second vertex of the triangle
• glColor3f(0, 0, 1); // set the color to blue
• glVertex3f(0, 1, 0); // define the third vertex of the triangle
• glEnd();
• This specifies a triangle with vertices at (1, 0, 0), (0, 1, 0), and (0, 0, 1) with
the color red, green, and blue respectively, normal vector (0, 0, 1) and
texture coordinates (0, 0), (0, 1) and (1, 1) respectively.
 THE END!
QUESTIONS
?????

75