/* Wei Wang <wei.z.wang@intel.com> */

#include <stdlib.h>
#include <GL/glut.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>


#define SKIP_ROWS    7
#define SKIP_PIXELS  7
#define BITMAP_TOTAL_W  64
#define BITMAP_TOTAL_H  64
#define ALIGN 1

typedef struct _bitmap_t {
    GLint total_w;
    GLint total_h;
    GLubyte *data;
} bitmap_t;

/* Global Vars */
static bitmap_t mybitmap;
static GLint row_len, align;


void print_bitmap_data(bitmap_t *bitmap)
{
    int i, j;
    for (i = 0; i < bitmap->total_h; i++) {
        printf("[%2X]  ", i);
        for (j = 0; j < (bitmap->total_w/8); j++) {
            printf("%2X ", bitmap->data[(bitmap->total_w/8) * i + j]);
        }
        printf("\n");
    }
}



int gen_bitmap(bitmap_t *bitmap, GLint totalW, GLint totalH)
{
    GLint total_width, total_height;
    GLint i, j;
    GLubyte *data = NULL;
    int tmp;

    total_width = 8 * ((totalW + 7) / 8);
    total_height = totalH;

    data = (GLubyte *)malloc(total_width/8 * total_height);
    if (! data)
        return -1;

    for (i = 0; i < total_height; i++) {
        for (j = 0; j < (total_width/8); j++) {
            data[(total_width/8) * i + j] = (GLubyte) rand();
        }
    }

    bitmap->data = data;
    bitmap->total_w = total_width;
    bitmap->total_h = total_height;

    return 0;
}



void destroy_bitmap(bitmap_t *bitmap)
{
    if (bitmap->data)
        free(bitmap->data);
}


void zero_bitmap_data(bitmap_t *bitmap)
{
    memset(bitmap->data, 0, bitmap->total_w/8 * bitmap->total_h);
}


void display(void)
{
    glClear (GL_COLOR_BUFFER_BIT);

    glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, row_len);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, SKIP_ROWS);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, SKIP_PIXELS);
    glPixelStorei(GL_UNPACK_ALIGNMENT, align);

    glColor3f (1.0, 0.0, 0.0);  //whatever
    glPolygonStipple (mybitmap.data);

    glEnable (GL_POLYGON_STIPPLE);
    glBegin(GL_POLYGON);
    glVertex2f(0,0);
    glVertex2f(32, 0);
    glVertex2f(32, 32);
    glVertex2f(0, 32);
    glEnd();
    glDisable (GL_POLYGON_STIPPLE);
    glPopClientAttrib();

    print_bitmap_data(&mybitmap);

    zero_bitmap_data(&mybitmap);
    glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
    glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
    glPixelStorei(GL_PACK_ROW_LENGTH, row_len);
    glPixelStorei(GL_PACK_SKIP_ROWS, SKIP_ROWS);
    glPixelStorei(GL_PACK_SKIP_PIXELS, SKIP_PIXELS);
    glPixelStorei(GL_PACK_ALIGNMENT, align);
    glGetPolygonStipple(mybitmap.data);
    glPopClientAttrib();

    printf("-----------------------------\n");
    print_bitmap_data(&mybitmap);

    glFlush ();
}





void init (void)
{
    glClearColor (0.0, 0.0, 0.0, 0.0);
    glShadeModel (GL_FLAT);

    gen_bitmap(&mybitmap, BITMAP_TOTAL_W, BITMAP_TOTAL_H);
    row_len = BITMAP_TOTAL_W;
    align = ALIGN;
}

static void reshape(GLsizei w, GLsizei h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

static void
key(unsigned char k, int x, int y)
{
  switch (k) {
  case 27:  /* Escape */
    exit(0);
    break;
  default:
    break;
  }
  glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGBA);
    glutInitWindowSize (100, 100);
    glutCreateWindow (argv[0]);
    init ();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(key);
    glutMainLoop();
    return 0;
}