binary translation for a glPolygonStipple argument - opengl

Question

I am trying to learn the language from http://www.glprogramming.com/red/chapter02.html At that site there is an example on how to use glPolygonStipple. My understanding is the hexadecimal numbers in the GLubyte arrays are held to translate to binary numbers so it can make a bitmap. I just was wondering how exactly are the elements in these arrays making these patterns.
Here is the example from the website on this:
#include <Windows.h>
#include <GL/gl.h>
#include <GL/glut.h>
void display(void)
{
GLubyte fly[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60,
0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20,
0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20,
0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC,
0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30,
0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0,
0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0,
0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30,
0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08,
0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08,
0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};
GLubyte halftone[] = {
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55};
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
/* draw one solid, unstippled rectangle, */
/* then two stippled rectangles */
glRectf (25.0, 25.0, 125.0, 125.0);
glEnable (GL_POLYGON_STIPPLE);
glPolygonStipple (fly);
glRectf (125.0, 25.0, 225.0, 125.0);
glPolygonStipple (halftone);
glRectf (225.0, 25.0, 325.0, 125.0);
glDisable (GL_POLYGON_STIPPLE);
glFlush ();
}
void init (void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (350, 150);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Answer 1

Binary is a base 2 number system, which means each digit is a 0 or a 1. This lends itself very well to stipple patterns, because a 0 means "don't draw this pixel", and a 1 means "draw this pixel". The stipple pattern used across a polygon is 2 dimensional, so you have several rows of these 0's and 1's, building up a pattern of pixels.
To be specific, you have 32 rows of 32 binary digits (bits) each.
Unfortunately you can't enter binary numbers into the source code of languages such as C and C++. Hexadecimal is commonly used instead. It's a base 16 number system, so each digit can be 0-9 or A-F (the letters A-F represents decimal values 10-15).
The nice thing about it is that each digit neatly corresponds to a pattern of 4 binary digits (or bits). That makes it very easy to convert. Here's how they correspond:
Hex Binary
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
A 1010
B 1011
C 1100
D 1101
E 1110
F 1111
(If you're not familiar with how numbers are represented in binary, then that might look strange. There should be plenty of tutorials and explanations online though if you want to learn more about the details.)
When you see a hex number such as 0x31, you can firstly ignore the "0x" prefix -- that just indicates that the number is in hexadecimal. To figure out the binary equivalent, just look up the other digits in the table, one at a time, to get the binary equivalent. In this case, it's a 3 followed by a 1, which means the binary pattern is 0011 0001 (without the space).
In a stipple pattern, that means it will leave 2 pixels blank, draw 2 pixels, leave 3 pixels blank, and finally draw 1 pixel.
In the example code you posted, you can see several pairs of hex digits. Each hex pair gives you 8 binary bits (or 1 byte). That means 4 consecutive pairs of hex digits is 32 bits, which is one complete row of the stipple pattern. There are 32 rows in total.
It's worth noting that the example code has slightly confusing formatting. It's showing 8 hex pairs per line of source code. OpenGL doesn't care about that though. It just sees a contiguous array of numbers, which it splits into 32 bits per row.