Computer Graphics Chapter 4

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.

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.

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 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).

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.

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.

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).

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).

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