Computer Graphics Chapter 4

Podcast Beta

Play an AI-generated podcast conversation about this lesson

Questions and Answers

Which function in OpenGL is specifically designed for drawing rectangles?

glVertex2iv()

glRecti() (correct)

glBegin(GL_POLYGON)

glEnd()

What function is used in OpenGL to draw rectangles efficiently?

glRect*

To draw only outlines or vertices, which function is used?

glPolygonMode()

What function is used to determine whether a pixel should be drawn or skipped based on a pattern?

glLineStipple Signup and view all the answers

Match the following fill-area functions with their descriptions:

GL_POLYGON = Displays a single convex polygon GL_TRIANGLES = Treated as groups of 3 triangle vertices GL_TRIANGLE_STRIP = Displays a set of connected triangles GL_TRIANGLE_FAN = First vertex is the 'source' of the fan GL_QUADS = Treated as groups of 4 quadrilateral vertices Signup and view all the answers

Which function is used to adjust the line width in OpenGL?

glLineWidth Signup and view all the answers

Antialiasing in OpenGL enables the possibility of non-integer line widths.

True Signup and view all the answers

To set the line color in OpenGL, which function is used? glColor__();

3f Signup and view all the answers

What function in OpenGL allows you to set the size of rendered points?

glPointSize Signup and view all the answers

Match the OpenGL triangle drawing primitives with their descriptions:

GL_TRIANGLES = 3 consecutive vertices form separate triangles GL_TRIANGLE_STRIP = Connect each vertex with the last two vertices to form triangles GL_TRIANGLE_FAN = Each subsequent vertex forms a triangle with the previous vertex and a fixed center vertex Signup and view all the answers

Which function is used to specify the color of points in OpenGL?

glColor3f Signup and view all the answers

What is the default point size in OpenGL?

1 pixel Signup and view all the answers

In OpenGL, non-integer widths for points are rounded when antialiasing is disabled.

True Signup and view all the answers

Adjacent vertices in GL_LINE_STRIP are considered ________________.

lines Signup and view all the answers

What are two ways of representing characters mentioned in the text?

Bitmap (raster) and Stroke (outline) Signup and view all the answers

Which font type always takes up the same width on the display?

Monospace font Signup and view all the answers

Glut library supports the display of ________ characters.

character Signup and view all the answers

Bitmap characters are represented as 2D arrays?

True Signup and view all the answers

Study Notes

OpenGL Point Functions

Points are the simplest geometric primitive in OpenGL and are often used to represent individual pixels or as markers in a larger scene.
The glPointSize(size) function allows you to set the size of the rendered points, where the size parameter specifies the diameter of the points in pixels.
The default point size is 1 pixel.
Points are drawn as squares with a side length equal to the point size.
To begin working with points in OpenGL, use glBegin(GL_POINTS) and glEnd() to indicate the start and end of a group of points.
The glVertex2f(x, y) function is used to specify the coordinates of a 2D point, and glVertex3f(x, y, z) is used for 3D points.
If a 2D point is specified, OpenGL will create a 3D point with z=0.
The glColor3f(r, g, b) function is used to specify the color of the points, where r, g, and b represent the red, green, and blue components of the color, respectively.

OpenGL Line Functions

There are three kinds of line primitives in OpenGL: GL_LINES, GL_LINE_STRIP, and GL_LINE_LOOP.
GL_LINES draws unconnected line segments, where each pair of vertices defines a separate line segment.
GL_LINE_STRIP draws a connected sequence of line segments, where each vertex shares an endpoint with the previous one.
GL_LINE_LOOP draws a connected sequence of line segments, and also connects the last vertex to the first vertex, forming a closed loop.
Line style refers to the pattern or appearance of a line, and can be specified using a pixel mask or stippled lines.
To enable line stipple, use glEnable(GL_LINE_STIPPLE) and glLineStipple(repeatFactor, pattern) to define the line style.
Line width can be adjusted using glLineWidth(width), which takes a single argument representing the desired line width.
Line color can be set using glColor3f(r, g, b), which takes three arguments representing the RGB values of the desired color.

OpenGL Polygon Fill-Area Functions

Triangles are one of the basic building blocks used to create complex shapes and 3D models in computer graphics.
There are three kinds of triangle primitives in OpenGL: GL_TRIANGLES, GL_TRIANGLE_STRIP, and GL_TRIANGLE_FAN.
GL_TRIANGLES draws separate triangles, where each group of three consecutive vertices forms a separate triangle.
GL_TRIANGLE_STRIP generates triangles by connecting each vertex with the two previous vertices in the stream.
GL_TRIANGLE_FAN generates triangles by connecting each vertex to the previous vertex and the center vertex, creating a fan-like shape.
Fill-area primitives refer to any enclosed boundary that can be filled with a solid color or pattern.### Fill-Area Primitives
Fill-area primitives are normally polygons, which can be filled efficiently by graphics packages.
A polygon is a 2D shape whose boundary is formed by any number of connected straight-line segments.
Polygons are defined by 3 or more coplanar vertices (points positioned on the same plane).
Each pair of adjacent vertices is connected in sequence by edges.

Fill-Area Patterns

Fill-area patterns allow you to apply various predefined patterns to the interior of polygons.
Options for filling a defined region include:
- Choice between a solid color or a pattern fill.
- Choices for particular colors and patterns.
OpenGL provides six different symbolic constants for different patterns:
- GL_FILL (default option, fills the polygon with a solid color).
- GL_POINT (fills the polygon with a dot pattern).
- GL_LINE (fills the polygon with a pattern of parallel lines).
- GL_FILL (fills the polygon with a checkerboard pattern).
- GL_FILL (fills the polygon with a hatched pattern).
- GL_FILL (fills the polygon with a stippled pattern).

Enabling Polygon-Fill Feature

To enable the fill-area pattern feature, use the glPolygonMode() function with the GL_POLYGON parameter for the face argument and the desired pattern constant for the mode argument.
The parameter face can be GL_FRONT_AND_BACK, GL_FRONT, or GL_BACK.
The mode can be GL_POINT, GL_LINE, or GL_FILL to indicate whether the polygon should be drawn as points, outlined, or filled.

Drawing Polygons

Once the fill-area pattern is enabled, you can proceed to draw your polygons using the glBegin() and glEnd() functions.
The fill-area pattern will be automatically applied to the interior of the polygons.

Other Polygon Drawing Methods

Another way to draw rectangles is using the glRect* routine, which is specifically designed for drawing rectangles in OpenGL.
The glRect* routine takes four arguments: x1, y1, x2, and y2, which represent the coordinates of the opposite corners of the rectangle.
OpenGL will construct a polygon with vertices defined in the following order: (x1,y1), (x2,y1), (x2,y2), (x1,y2).

Character Primitives

Many pictures require text.
Attributes of character primitives include font size, color, and orientation.
Most graphics packages have some support for displaying character primitives.
Type faces (fonts) can be divided into two:
- Serif (has small lines or accents at the ends of the main character stroke).
- Sans-serif (does not have accents).

Representing Characters

There are two ways to represent characters:
- Bitmap (raster): a binary pattern defined on a rectangular grid.
- Stroke (outline): defined using line/curve primitives.