Computer Science
Chapter Four
Geometry and Line Generation
1/28/23 Computer Graphics Getie B. MAU-CS
Graphics Primitives
2
All graphics packages construct pictures from basic
building blocks known as graphics primitives.
Output Primitives: Basic geometric structures
(points, straight line segment, circles, quadric
surfaces, spline curve and surfaces, polygon color
areas, and character strings)
Geometric primitives: primitives or routines to
describe the geometry (i.e. shape) of objects e.g.
Point drawing, Line drawing, Polygon drawing,…
- They can be 2-D primitives (points, lines, quadrilaterals,
& general polygons) and more complex 3-D primitives
(spheres and polyhedral (polyhedron is a 3-D surface
1/28/23made from a mesh of 2-D polygons))
Computer Graphics Getie B. MAU – CS
Attributes Output Primitives
3
Attribute – any parameter that affects the way a
primitive will be displayed
e.g.: Colour, type, line thickness, fill style, etc.
OpenGL maintain a list of current state variables
that are used to modify the appearance of each
primitive as it is displayed.
Therefore these state variables represent attributes
of the primitives
All OpenGL state variables have default values
Remain in effect until new values specified
Some state variables can be changed within
glBegin() …Computer
1/28/23
glEnd()
Graphics
pairs Getie B. MAU – CS
Contd…
4
Output Primitive Attributes
Point Size
Color
Line Thickness (1pt, 2pt …)
Type (Dashed, Dotted, Solid)
Color
Text Font (Arial, Courier, Times Roman…)
Size (12pt, 16pt ..)
Spacing
Orientation (Slant angle)
Style (Bold, Underlined, Double lined)
Color
Filled Region Fill Pattern
Fill Type (Solid Fill, Gradient Fill)
Fill Color
Images Color Depth (Number of bits/pixel)
1/28/23 Computer Graphics Getie B. MAU – CS
5
OpenGL Point Drawing Functions
Point – is the most basic type of output primitive
use the pair of functions glBegin … glEnd, using the
symbolic constant GL_POINTS to specify the vertex and
other properties.
Point attributes:
- Point size: glPointSize(size); E.g glPointSize(10.0);
Points are drawn as squares with a side length equal to
the point size. default point size is 1 pixel.
- Point colour: glColor* e.g glColor3f(0,1,0);
glVertex*- to identify the location of points
* specifies # of arguments, and type of
arguments, e.g.
glVertex3f: 3 Glfloat arguments
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
6
The following code fragment draws three 2-D points
with
a size of 2 pixels which illustrates an example of how
the sequences of vertices are passed to OpenGL
void displaypoint(void){
glPointSize(2.0);
glClear(GL_COLOR_BUFFER_BIT); // Clear Screen
glColor3f(0,1,0);
glBegin(GL_POINTS); // draw 3 points
glVertex2i(50,100);
glVertex2i(100,150);
glVertex2i(150,200);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
7
We can set the OpenGL routines attributes for each
drawing points:
glColor3f(1.0, 0.0, 0.0);
glBegin(GL_POINTS);
glVertex2i(50, 100);
glPointSize(2.0);
glColor3f(0.0, 1.0, 0.0);
glVertex2i(100, 150);
glPointSize(3.0);
glColor3f(0.0, 0.0, 1.0);
glVertex2i(150,200);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
Line Drawing Algorithms 8
Lines are a very common primitive and will be supported by
almost all graphics packages.
Lines form the basis of more complex primitives such as polylines
(a connected sequence of straight-line segments) or polygons (2-D
objects formed by straight-line edges)
Lines are normally represented by the two end-points, and points
(x,y) along the line must satisfy slope-intercept straight-line
equation:
y = mx + c…………………………………………... (1)
(m= slope or gradient, c= coordinate at which the line intercepts y-axis)
Given end points (x0, y0) and (xend, yend) we can calculate
m = (yend - y0)/(xend - x0) ……………… (2)
c = y0 - m.x0…………………………...………… (3)
Two line-drawing algorithms: DDA algorithm and Bresenham’s
algorithm
For any given x-interval δx(x increment), we can find the
corresponding y-interval δy(y increment):
Line Drawing: DDA Algorithm
9
DDA=Digital Differential Analyser
Operates: starting at one end-point of the line, and
then using Eqs. (4) and (5) to generate successive
pixels until the second end-point is reached.
For lines with |m|≤1: line more horizontal than
vertical
Start with (x0, y0), successive pixel positions calculated
using δx=1, δy=m
e.g (2,2) to (9,2) and (5,4) to (12,7)
For lines with |m|>1: line more vertical than
horizontal
Start with (x0, y0), successive pixel positions calculated
using δx=(1/m), δy=1 e.g
E.g (2,5) to (2,12) and (5,7) to (10,15)
Contd…
10
Example:
m=3/5=0.6
|m|≤1, so
δx=1, δy=0.6
Start with (x0,y0) = (10,10) – colour this pixel
Next, (x1,y1) = (10+1,10+0.6) = (11,10.6) – so we colour pixel (11,11)
Next, (x2,y2) = (11+1,10.6+0.6) = (12,11.2) – so we colour pixel (12,11)
Next, (x3,y3) = (12+1,11.2+0.6) = (13,11.8) – so we colour pixel (13,12)
Next, (x4,y4) = (13+1,11.8+0.6) = (14,12.4) – so we colour pixel (14,12)
Next, (x5,y5) = (14+1,12.4+0.6) = (15,13) – so we colour pixel (15,13)
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
11
AlgorithimDDA(x1,y1,xend,yend)
{
dx=xend-x1, dy=yend-y1;
If(abs(dx)>abs(dy)
step=abs(dx);
Else
Step=abs(dy);
Xincrement=dx/steps; Yincrement=dy/steps;
For(i=1;i<=step;i++)
{
putPixel(x1,y1);
x1=x1+Xincrement;
y1=y1+Yincrement;
}}
1/28/23
Computer Graphics Getie B. MAU – CS
12
Line Drawing: Bresenham’s Algorithm
DDA Algorithm generate floating point numbers. The
calculation of float takes extra time compare to integer. so
the algorithm is slow & time consuming. The algorithm
takes round technique to plot the pixel value. Due to this
the line is not smooth.
Bresenham’s algorithm uses only integer operations –
much faster
If we know the previous pixel location, we only have
a choice of 2 locations for the next pixel,
At each stage, we need to decide which of
A=(xk+1, yk+1)
B=(xk+1,yk) pixel to choose
Therefore we do not need to compute the actual
13
Bresenham’s Algorithm
Bresenham’s algorithm works as follows. First, we denote by
dupper and dlower the distances between the centres of pixels A and
B and the ‘true’ line.
Using Eq. (1) the ‘true’ y-coordinate at xk+1 can be calculated as:
1/28/23 Computer Graphics Getie B. MAU – CS
14
Bresenham’s Algorithm
If the value of this expression is positive we choose pixel A;
otherwise we choose pixel B. The question now is how we can
compute this value efficiently. To do this, we define a decision
variable pk for the kth step in the algorithm and try to formulate pk
so that it can be computed using only integer operations. To achieve
this, we substitute.
• where d is a constant that has the value
Note that the sign of pk will be the same as the sign of (dlower –
dupper), so if pk is positive we choose pixel A and if it is negative
we choose pixel B.
Next calculate how much the decision variable changes every
time (pk incremental calculation=pnext-pk).
Given that we know a value for pk, we can calculate pk+1 from Eq.
(10) by observing that:
1/28/23 Computer Graphics Getie B. MAU – CS
15
Bresenham’s Algorithm
The initial value for the decision variable, p0, is calculated by
substituting xk = x0 and yk = y0 into Eq. (10), which gives the
following simple expression:
Summary
1/28/23 Computer Graphics Getie B. MAU – CS
16
Bresenham’s Algorithm
Consider the example of plotting the line shown below using Bresenham’s algorithm:
Bresenham’s Algorithm
AlgorithimBresnham(x0,y0,xend,yend)
17
{
X=x0, Y=y0;
dx=xend-x0, dy=yend-y0;
P=2dy-dx;
While(x<=xend)
{
Plotpixel(X,Y);
X++;
If(p<0)
{
P=p+2dy;
}
Else
{ p=p+2dy-2dx;
Y++;
}} }
Computer Graphics Getie B. MAU – CS
18
OpenGL Line Drawing Primitives
3 kinds of line primitives, based on different
interpretations of a vertex stream.
- GL_LINES: Vertices 0 and 1 are considered a
line. Vertices 2 and 3 are considered a line and
so on. If the user specifies a non-even (odd)
number of vertices, then the extra vertex is
ignored
- GL_LINE_STRIP: adjacent vertices are
considered lines. Thus, if you pass n vertices,
you will get n-1 lines. If the user only specifies
1 vertex, the rendering command is ignored.
- GL_LINE_LOOP: As line strips, except that
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
19
GLint p1[] = {200,100}; GLint p2[] = {50,0}
GLint p3[] = {100,200}; GLint p4[]={150,0}; GLint p5[]
= {0,100};
GL_LINES
Unconnected line segments
GL_LINE_STRIP
Connected line segments(a polyline)
GL_LINE_LOOP
Connected line segments, and last
point connected to first point
OpenGL Line Functions
20
We can draw using the same glBegin … glEnd functions
we specify that vertices should be interpreted as line end-
points
by using the symbolic constant GL_LINES
E.g.,
glLineWidth(3.0);
glBegin(GL_LINES);
glVertex2f(200.0, 100.0);
glVertex2f(50.0, 0.0);
glVertex2f(100.0, 200.0);
glVertex2f(150.0, 0.0);
glVertex2f(0.0, 100.0);
glEnd()
line will be drawn in the current drawing colour and with
Contd…
21
GL_LINE_STRIP and GL_LINE_LOOP
GLint p1[] = {200,100}; GLint p2[] = {50,0}
GLint p3[] = {100,200}; GLint p4[]={150,0};
GLint p5[] = {0,100};
glBegin(GL_LINE_STRIP);
glVertex2i(p1);
glVertex2i(p2);
glVertex2i(p3);
glVertex2i(p4);
glVertex2i(p5);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2i(p1);
glVertex2i(p2);
glVertex2i(p3);
glVertex2i(p4);
glVertex2i(p5);
glEnd();
Line Attributes
22
Line Attribute: there are 3 most common
attributes
- Line type- solid, dashed and dotted lines
- Line Width
- Line Color
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
23
Width - tickness
Specify in pixels and proportion of a
standard line width
Issues:
Line have different thickness on the slope
Problem with
End of the line
Joining the two lines (polygon)
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
24
Width
simplest and most common technique for
increasing the width of a line
plot a line of width 1 pixel, and then
add extra pixels in either the horizontal or
vertical directions
these two approaches we use depends on
gradient m of line
If |m| ≤ 1: line more horizontal than vertical
plot extra pixels vertically, i.e. same x-
coordinate, different y-coordinate, as
If |m| > 1 :Computer
1/28/23
line Graphics
more vertical Getie
than horizontal
B. MAU – CS
Contd…
25
Width
Fig. Increasing Line Width by Plotting Extra Pixels in the
Vertical (a) and Horizontal (b) directions
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
26
Width
Two problems with
technique:
- Thickness depends on
slope, e.g.
If slope = 0, plotting
n pixels gives
thickness n
If slope = 1 (45o),
plotting n pixels
gives thickness of
n/√2
- Ends of lines:
depending on whether
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
27
Width
Answer to the second problem – use line caps
Line cap is a shape that is applied to the end of
the line only to give them a better appearance
Three types of line cap are common in computer
graphics:
- Butt cap - is formed by drawing a line through
each end-point at an orientation of 90o to the
direction of the line
- Round cap - formed by drawing a semi-circle at
each end-point with radius equal to half the line
1/28/23width Computer Graphics Getie B. MAU – CS
Contd…
28
Width
Types of line cap
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
29
The process introduce a new problem
If we are drawing polylines, or a connected
series of line segments, with these line caps, we
can get problems at line joins
For example
what happens at the line join of two line
segments drawn with butt caps
There is a small triangular area at the join that
does not get filled
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
30
To overcome this problem – use the following
join types:
Miter join – extend the outer boundaries of each
of the two lines until they meet
Round join – draw a circular boundary centred
on the join point with a diameter equal to the line
width
Bevel join – use butt caps, then fill in triangle
that is left unfilled
Line join
types
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
31
Style
Solid
Dotted – very short dash with spacing
equal to or greater than dash itself
Dashed – displayed by generating an interdash spacing
normal approach to change line style – define a
pixel mask
- Pixel mask means a sequence of bit values that
determine whether pixels in the plotted line should be
on or off, e.g.,
- Mask 11111000 specifies a dash length of 5 pixels
followed by a spacing of 3 pixels
- In other words,
1/28/23 if bit in PM plot pixel Getie B. MAU – CS
is 1Graphics
Computer
Contd…
32
Line style – is specified using a pixel mask
Stippled lines – to make stippled (dotted or dashed)
lines
Firstly, must enable line stipple using:
glEnable(GL_LINE_STIPPLE);
Next, use glLineStipple function to define line style, takes
2 arguments: a
glLineStipple(GLint repeatFactor, GLushort
pattern);
repeatFactor, specifies how many times each bit in
the pixel mask should be repeated, and
pattern, which is a 16-bit pixel mask, with the low-
order
1/28/23
bit used first – series
Computer Graphics
of 0’s and 1’s
Getie B. MAU – CS
Contd…
33
glEnable(GL_LINE_STIPPLE);
glLineWidth(3.0);
glLineStipple(1, 0x00FF);
glBegin(GL_LINE_STRIP);
glVertex2i(100,100);
glVertex2i(150,100);
glVertex2i(150,200);
glVertex2i(250,250);
glEnd();
glDisable(GL_LINE_STIPPLE);
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
34
1/28/23 Computer Graphics Getie B. MAU – CS
Triangle Drawing Primitives
35
triangle - a primitive formed by 3 vertices
It is the 2D shape with the smallest number of
vertices
3 kinds of triangle primitives, based again on
different interpretations of the vertex stream:
- GL_TRIANGLES: vertices 0, 1, and 2 form a triangle.
Vertices 3, 4, and 5 form a triangle. And so on.
- GL_TRIANGLE_STRIP: Every group of 3 adjacent
vertices forms a triangle. A vertex stream of n length
will generate n-2 triangles
- GL_TRIANGLE_FAN: The first vertex is always
held fixed. From there on, every group of 2 adjacent
1/28/23vertices form a triangle
Computer Graphicswith the first.
Getie So with
B. MAU – CS a vertex
Contd…
36
GL_TRIANGLES:
Vertex list treated as groups of three triangle vertices
Vertices must be specified in anti-clockwise order
GLint p1[] = {50,100};GLint p2[] = {100,10};GLint p6[] =
{100,200};
GLint p3[] = {150,10};GLint p5[] = {150,200};GLint p4[]=
{200,100};
glBegin(GL_TRIANGLES);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p6);
glVertex2iv(p3);
glVertex2iv(p4);
Contd…
37
GL_TRIANGLE_STRIP:
Displays set of connected triangles
First triangle vertices must be anti-clockwise
E.g.
glBegin(GL_TRIANGLE_STRIP);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p6);
glVertex2iv(p3);
glVertex2iv(p5);
glVertex2iv(p4);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
38
GL_TRIANGLE_FAN:
First vertex is the ‘source’ of the fan
Subsequent pairs of vertices form triangles with the first
one
E.g.
glBegin(GL_TRIANGLE_FAN);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p3);
glVertex2iv(p4);
glVertex2iv(p5);
glVertex2iv(p6);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
39
Writing Assignments
Discuss about
- Circle Generating Algorithms
- Ellipse Generating Algorithms
Write pseudo codes and flowchart for the above
generating algorithms.
1/28/23 Computer Graphics Getie B. MAU – CS
Fill-Area Primitives
40
Refers to any enclosed boundary that can be filled
with a solid colour or pattern
How do we fill shapes?
Texture Fill
Solid Fill Pattern Fill
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
41
Fill-area primitives are normally polygons, as they
can be filled more efficiently by graphics packages
Fill-Area algorithms are used to fill the interior of a
polygonal shape
If the polygon is to be filled we can specify a fill style
Options for filling a defined region include
- choice between a solid color or a pattern fill and
- choices for particular colors and patterns
Polygons are 2-D shapes whose boundary is formed
by any number of connected straight-line segments
- defined by 3 or more coplanar vertices (points positioned
on the same plane)
- Each pair of adjacent
1/28/23 vertices is connected
Computer Graphics in –sequence
Getie B. MAU CS by
Contd…
42
Normally polygons should have no edge crossings: in
this case they are known as simple polygons or
standard polygons
Edge crossings, e.g.
Polygons are the most common form of graphics
primitive because they form the basis of polygonal
meshes, which is the most common representation for
3-D graphics objects.
Polygonal meshes approximate curved surfaces by
forming a mesh of simple polygons.
1/28/23 Computer Graphics Getie B. MAU – CS
43
Reading Assignments
Concave and Convex Polygons
Identify concave polygons
Splitting concave polygons
Polygon Inside-Outside Tests
Representing polygons
Polygon Front and Back faces
Polygon Normal Vectors
1/28/23 Computer Graphics Getie B. MAU – CS
44
OpenGL Polygon Fill-Area Functions
To fill polygons with a fill-area pattern:
- Define the pattern
- Enable polygon-fill feature of OpenGL
- Draw polygons
A number of different ways:
glRect*
6 different symbolic constants
For all:
Polygons must be convex
Must specify vertices in anti-clockwise order when
viewing the polygon from “outside”
Default fill-style is solid color, determined by current
color settings Computer Graphics
1/28/23 Getie B. MAU – CS
Contd…
45
glRect*
Because rectangles are a common primitive to display,
OpenGL provides a special routine that takes 2-D
points only.
glRect* (x1, y1, x2, y2)
where (x1,y1) and (x2,y2) define opposite corners of
the rectangle. Actually when we call the glRect*
routine, OpenGL will construct a polygon with
vertices defined in the following order:
(x1,y1), (x2,y1), (x2,y2), (x1,y2).
Specify opposite corners of the rectangle,
e.g: glRecti(200,100,50,250);
Can draw rectangles with other functions,
but glRect*can be
1/28/23
more efficient Getie B. MAU – CS
Computer Graphics
Contd…
46
All other fill-area functions use the functions
glBegin… glEnd:
GL_POLYGON
GL_TRIANGLES
GL_TRIANGLE_STRIP
GL_TRAINGLE_FAN
GL_QUADS
GL_QUAD_STRIP
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
47
GL_POLYGON:
Displays a single convex polygon
Vertices of the polygon are specified in anti-clockwise
direction
E.g.
glBegin(GL_POLYGON);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p3);
glVertex2iv(p4);
glVertex2iv(p5);
glVertex2iv(p6);
1/28/23glEnd(); Computer Graphics Getie B. MAU – CS
Contd…
48
GL_TRIANGLES:
Vertex list treated as groups of three triangle vertices
Vertices must be specified in anti-clockwise order
E.g.
glBegin(GL_TRIANGLES);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p6);
glVertex2iv(p3);
glVertex2iv(p4);
glVertex2iv(p5);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
49
GL_TRIANGLE_STRIP:
Displays set of connected triangles
First triangle vertices must be anti-clockwise
E.g.
glBegin(GL_TRIANGLE_STRIP);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p6);
glVertex2iv(p3);
glVertex2iv(p5);
glVertex2iv(p4);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
50
GL_TRIANGLE_FAN:
First vertex is the ‘source’ of the fan
Subsequent pairs of vertices form triangles with the first
one
E.g.
glBegin(GL_TRIANGLE_FAN);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p3);
glVertex2iv(p4);
glVertex2iv(p5);
glVertex2iv(p6);
glEnd();
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
51
GL_QUADS:
Vertex list treated as groups of four quadrilateral
vertices
Vertices must be specified in anti-clockwise order, E.g.
glBegin(GL_QUADS);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p3);
glVertex2iv(p4);
glVertex2iv(p5);
glVertex2iv(p6);
glVertex2iv(p7);
glVertex2iv(p8);
1/28/23glEnd(); Computer Graphics Getie B. MAU – CS
Contd…
52
GL_QUAD_STRIP:
One quadrilateral drawn for each pair of vertices after
the first two
E.g.
glBegin(GL_QUAD_STRIP);
glVertex2iv(p1);
glVertex2iv(p2);
glVertex2iv(p3);
glVertex2iv(p4);
glVertex2iv(p5);
glVertex2iv(p6);
glVertex2iv(p7);
glVertex2iv(p8);
1/28/23glEnd();
Computer Graphics Getie B. MAU – CS
Character Primitives 53
Character primitives can be used to display text
characters.
Many pictures require text.
attributes: Font size, Color and Orientation
Attributes can be set both for entire character strings
(text) and for individual characters
Most graphics packages have some support for
displaying character primitives
Type Faces (fonts) can be divided into two:
Serif – has small lines or Arial
accents
is aat the endsfont
sans-serif of the
main character stroke. And soVerdana
makes readable.
is a sans-serif font
Sans-Serif – does not have Times Roman is a serif font
accents.
Garamond is a serif font
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
54
Another category of fonts
Monospace font: always take up the same width on the display,
regardless of which character is being drawn. monospace fonts
use the same width for each character.
Proportional fonts: width used on the display will be
proportional to the actual width of the character.
Two ways of representing characters:
Bitmap (Raster):
Bitmap fonts represent characters using a grid of pixel
values. They are efficient to draw but not easily scalable.
Binary pattern defined on rectangular grid
Each character represented (stored) as a 2-D array
- Each element corresponds to a pixel in a rectangular
“character cell”
- Simplest: each element is a bit (1=pixel on, 0=pixel off)
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
55
Two ways of representing characters:
Bitmap (Raster)
00111000
01101100
11000110
11000110
11111110
11000110
11000110
00000000
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
56
Stroke(outline)
Stroke (or outline) fonts represent characters using
line or curve primitives. They are less efficient to
draw but are easily scalable.
Each character represented (stored) as a series of
line segments
Takes longer time draw than bitmap fonts
we can change the font, colour, and also line width
and line style
Therefore the width of these lines can be changed
using
glLineWidth
style of the lines using
1/28/23 Computer Graphics Getie B. MAU – CS
57
OpenGL Character Primitives functions
glut library supports display of character
primitives
All characters displayed at current raster position:
glRasterPos2i(x, y);//positions the raster at coordinate
location (x,y).
Bitmap characters are drawn using
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, ‘a’);
//the number represents the height of the font.
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ‘a’);//This will
draw the character ‘a’ in a monospace bitmap font with width 9
and height 15 pixels.
To change colour of the character use
glColor* routine
Stroke characters, e.g.
Computer Graphics Getie B. MAU – CS
glutStrokeCharacter(GLUT_STROKE_ROMAN, ‘a’);//This will
OpenGL Color Modes
58
2 ways to specify colours in OpenGL:
- RGB:
Uses standard RGB colors (24-bit color, consisting
of 8 bits of red, green and blue) and is the default
3 numbers represent the amount of red, green and
blue in the colour
- RGBA:
Optional fourth value is the alpha coefficient
Specifies the degree of transparency of the
primitive
Useful for controlling colour blending for
overlapping primitives
1/28/23 If no alpha Computer
valueGraphics
is defined it is assumed
Getie B. MAU – CS to be
Contd…
59
glutInitDisplayMode, e.g.
- glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB)
glColor*, e.g.
- glColor3f(1.0,1.0,1.0); white foreground
glClearColor, e.g.
- glClearColor(0,0,0,0) black background
WHITE
1/28/23 Computer Graphics Getie B. MAU – CS
Contd…
60
Some color types
glColor3f(0.0, 0.0, 0.0); black
glColor3f(1.0, 0.0, 0.0); red
glColor3f(0.0, 1.0, 0.0); green
glColor3f(1.0, 1.0, 0.0); yellow
glColor3f(0.0, 0.0, 1.0); blue
glColor3f(1.0, 0.0, 1.0); magenta
glColor3f(0.0, 1.0, 1.0); cyan
glColor3f(1.0, 1.0, 1.0); white
1/28/23 Computer Graphics Getie B. MAU – CS
Contd… 61
void display(){
glClear(GL_COLOR_BUFFER_BIT); GLint xRaster = 125, yRaster = 450; // Initialize
glColor3f(0.0,1.0,0.0); raster position.
glRasterPos2i(15,30); void display(void)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'E');
{
glRasterPos2i(16,30);
glColor3f(1.0,1.0,0.0);
GLint l,k;
glClear(GL_COLOR_BUFFER_BIT); // Clear Screen
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'T');
glRasterPos2i(17,30); glColor3f (0.0, 0.4, 1.0); // Set text color to black.
glColor3f(1.0,0.0,0.0); glRasterPos2i(xRaster, yRaster);
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'H');
for ( k = 0; k < 27; k++)
glRasterPos2i(18,30); glutBitmapCharacter(GLUT_BITMAP_9_BY_15,
glColor3f(0.0,1.0,0.0); "Computer Science & IT Dep't"[k]);
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'I');
glRasterPos2i(19,30);
glColor3f(1.0,1.0,0.0); yRaster-=20;
glRasterPos2i(xRaster, yRaster);
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'O');
glRasterPos2i(20,30); for ( l = 0; l < 28; l++)
glColor3f(1.0,0.0,0.0); glutBitmapCharacter (GLUT_BITMAP_9_BY_15,
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'P');
"Welcome to Computer Graphics"[l]);
glRasterPos2i(21,30);
glColor3f(0.0,1.0,0.0);
glutStrokeCharacter (GLUT_STROKE_ROMAN, 'A');
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'I');
glRasterPos2i(22,30); glFlush(); // send all output to the display
glColor3f(1.0,0.0,0.0); }
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'A’);
glRasterPos2i(10,15);
glutStrokeCharacter(GLUT_STROKE_ROMAN,’A’);
62
Question
s?
Thank You!
1/28/23 Computer Graphics Getie B. MAU – CS
