The glBegin(GL_POINTS) function call tells OpenGL that each following vertex is to be rendered as a single point. Points can even have texture mapped onto them, and these are known as point sprites.

Points are actually generated as squares of pixels based on the size defined by the GL_PROGRAM_POINT_SIZE parameter of the glEnable function. The size defines the number of pixels that each side of the point takes up. The point's position is defined as the center of that square.

The point size must be greater than zero, or else an undefined behavior results. There is an implementation-defined range for point sizes, and the size given by either method is clamped to that range. Two additional OpenGL properties determine how points are rendered: GL_POINT_SIZE_RANGE (returns 2 floats), and GL_POINT_SIZE_GRANULARITY. This particular OpenGL implementation will clamp sizes to the nearest multiple of the granularity.

When you call glBegin(GL_LINES), every pair of vertices is interpreted as a single line. Vertices 1 and 2 are considered one line. Vertices 3 and 4 are considered another line. If the user specifies an odd number of vertices, then the extra vertex is ignored.

When you call glBegin(GL_LINES), the first vertex defines the start of the first line. Each vertex thereafter defines the end of the previous line and the start of the next line. This has the effect of chaining the lines together up to the last vertex in the list. Thus, if you pass n vertices, you will get n-1 lines. If the user only specifies only one vertex, the drawing command is ignored.

The call glBegin(GL_LINE_LOOP) works almost exactly like line strips, except that the first and last vertices are joined as a line. Thus, you get n lines for n input vertices. If the user only specifies one vertex, the drawing command is ignored. The line between the first and last vertices happens after all of the previous lines in the sequence.

When you call glBegin(GL_TRIANGLES), every three vertices define a triangle. Vertices 1, 2, and 3 form one triangle. Vertices 4, 5, and 6 form another triangle. If there are fewer than three vertices at the end of the list, they are ignored:

glBegin(GL_TRIANGLES);
  glVertex3f( 0.0f, 1.0f, 0.0f);
  glVertex3f(-1.0f,-1.0f, 0.0f);
  glVertex3f( 1.0f,-1.0f, 0.0f);
glEnd();

When you call glBegin(GL_TRIANGLE_STRIP), the first three vertices create the first triangle. Thereafter, the next two vertices create the next triangle, creating a group of adjacent triangles. A vertex stream of n length will generate n-2 triangles:

When you call glBegin(GL_TRIANGLE_FAN), the first vertex defines the point from which all other triangles are defined. Thereafter, each group of two vertices define a new triangle with the same apex as the first one, forming a fan. A vertex stream of n length will generate n-2 triangles. Any leftover vertices will be ignored:

When you call glBegin(GL_QUADS), each set of four vertices defines a quad. Vertices 1 to 4 form one quad, while vertices 5 to 8 form another. The vertex list must be a number of vertices divisible by 4 to work:

glBegin(GL_QUADS); 
  glVertex3f(-1.0f, 1.0f, 0.0f);
  glVertex3f( 1.0f, 1.0f, 0.0f);
  glVertex3f( 1.0f,-1.0f, 0.0f);
  glVertex3f(-1.0f,-1.0f, 0.0f);
glEnd();

Similarly to triangle strips, a quad strip uses adjacent edges to form the next quad. In the case of quads, the third and fourth vertices of one quad are used as the edge of the next quad. So, vertices 1 to 4 define the first quad, while 5 to 6 extend the next quad. A vertex list of n length will generate (n - 2)/2 quads: