/* Demonstration of simple texture mapping.  In this case, we create a
simple checkerboard texture, and use it in several different ways in
rendering a colored cube.

Based on Edward Angel's original cube.c program.

Written by Scott D. Anderson
Fall 2000
*/

/* Both textures and colors are assigned to the vertices */

#include <stdlib.h>
#include <stdio.h>
// This program doesn't actually use TW, but tw.h includes the GL header files
#include <tw.h>

GLfloat vertices[][3] = {
    {-1,-1,-1},           // left bottom back
    {1,-1,-1},            // right bottom back
    {1,1,-1},             // right top back
    {-1,1,-1},            // left top back
    {-1,-1,1},            // left bottom front
    {1,-1,1},             // right bottom front
    {1,1,1},              // right top front
    {-1,1,1}};            // left top front

GLfloat colors[][3] = {
    {0,0,0},                    // black
    {1,0,0},                    // red
    {1,1,0},                    // yellow
    {0,1,0},                    // green
    {0,0,1},                    // blue
    {1,0,1},                    // magenta
    {1,1,1},                    // white
    {0,1,1}};                   // cyan

/* ================================================================
   Texture stuff. The arrays are used in the texture mapping, and are
   initialized when the program begins, by a call to init_textures. */

#define TEXTURE_SIZE 64

typedef struct {
    GLubyte r;
    GLubyte g;
    GLubyte b;
} RGB_color;

GLubyte checkerboard[TEXTURE_SIZE*TEXTURE_SIZE];
// RGB_color checks_rgb[TEXTURE_SIZE*TEXTURE_SIZE];
GLubyte checks_rgb[TEXTURE_SIZE*TEXTURE_SIZE*3];

void init_textures() {
    int i,j;
    {
        /* The following is a black&white checkerboard.  It's done using a
           1D array where we do 8 black in a row, then 8 white in a row,
           and so forth. */
        int count=0;
        for(i=0;i<TEXTURE_SIZE;++i) 
            for(j=0;j<TEXTURE_SIZE;++j) {
                int is_dark = (i&8)^(j&8);
                checkerboard[count++] = !is_dark ? 255 : 0;
            }
    }
    {
        /* The following is a yellow and dark-green checkerboard. */
        int count=0;
        for(i=0;i<TEXTURE_SIZE;++i) 
            for(j=0;j<TEXTURE_SIZE;++j) {
                int is_dark = (i&8)^(j&8);
                if(!is_dark) {
                    checks_rgb[count++] = 255;
                    checks_rgb[count++] = 255;
                    checks_rgb[count++] = 0;
                } else {
                    checks_rgb[count++] = 0;
                    checks_rgb[count++] = 128;
                    checks_rgb[count++] = 0;
                }
            }
    }
}

/* Polgons as faces of a cube.  We set the color, normal and texture for
   each vertex. */

void polygon(int a, int b, int c , int d) {
    /* draw a polygon via list of vertices */
    glBegin(GL_POLYGON);
    glColor3fv(colors[a]);
    glTexCoord2f(0,0);
    glVertex3fv(vertices[a]);
    glColor3fv(colors[b]);
    glTexCoord2f(0,1);
    glVertex3fv(vertices[b]);
    glColor3fv(colors[c]);
    glTexCoord2f(1,1);
    glVertex3fv(vertices[c]);
    glColor3fv(colors[d]);
    glTexCoord2f(1,0);
    glVertex3fv(vertices[d]);
    glEnd();
}

void colorcube(void) {
    /* map vertices to faces */
    polygon(0,3,2,1);
    polygon(2,3,7,6);
    polygon(0,4,7,3);
    polygon(1,2,6,5);
    polygon(4,5,6,7);
    polygon(0,1,5,4);
}

void label(char* string) {
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glDisable(GL_TEXTURE_2D);
    glColor3f(1,0,0);
    glRasterPos3f(-1.5,-1.5,0);
    for (char* s = string; *s; s++)
        glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *s);
    glPopAttrib();
}

static GLfloat theta[] = {0,0,0};
static GLint axis = 2;

void display(void) {
    /* display callback, clear frame buffer and z buffer,
       rotate cube and draw, swap buffers */

    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glPushMatrix();
    glTranslatef(-1,-1,0);        /* lower left cube */
    glScalef(0.5,0.5,0.5);
    glRotatef(theta[0], 1, 0, 0);
    glRotatef(theta[1], 0, 1, 0);
    glRotatef(theta[2], 0, 0, 1);
    colorcube();
    label("original cube");
    glPopMatrix();

    /* From now on, we'll use textures */

    glEnable(GL_TEXTURE_2D);

    /* upper left cube: a luminance decal of a checkerboard on every
       face */

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexImage2D(GL_TEXTURE_2D,
                 0,                /* base level, no mipmaps */
                 0,                /* color components in texture */
                 TEXTURE_SIZE,        /* texture width */
                 TEXTURE_SIZE,        /* texture height */
                 0,                /* width of border: either 0 or 1 */
                 GL_LUMINANCE,        /* format of texture data */
                 GL_UNSIGNED_BYTE, /* data type of texture data */
                 checkerboard        /* pointer to array of texture data */
                 );

    glPushMatrix();
    glTranslatef(-1,+1,0);
    glScalef(0.5,0.5,0.5);
    glRotatef(theta[0], 1, 0, 0);
    glRotatef(theta[1], 0, 1, 0);
    glRotatef(theta[2], 0, 0, 1);
    colorcube();
    label("luminance decal");
    glPopMatrix();

    /* lower right cube: an rgb decal of a checkerboard on every face */

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexImage2D(GL_TEXTURE_2D, 0, 3, TEXTURE_SIZE, TEXTURE_SIZE, 0,
                 GL_RGB,        /* CHANGE!! format of texture data */
                 GL_UNSIGNED_BYTE, /* data type of texture data */
                 checks_rgb        /* pointer to array of texture data */
                 );

    glPushMatrix();
    glTranslatef(+1,-1,0);
    glScalef(0.5,0.5,0.5);
    glRotatef(theta[0], 1, 0, 0);
    glRotatef(theta[1], 0, 1, 0);
    glRotatef(theta[2], 0, 0, 1);
    colorcube();
    label("RGB decal");
    glPopMatrix();


    /* upper right cube: a checkerboard modulates the luminance on every
       face */

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0,
                 GL_LUMINANCE,        /* CHANGE!! format of texture data */
                 GL_UNSIGNED_BYTE, /* data type of texture data */
                 checkerboard        /* pointer to array of texture data */
                 );

    glPushMatrix();
    glTranslatef(+1,+1,0);
    glScalef(0.5,0.5,0.5);
    glRotatef(theta[0], 1, 0, 0);
    glRotatef(theta[1], 0, 1, 0);
    glRotatef(theta[2], 0, 0, 1);
    colorcube();
    label("luminance modulates RBG");
    glPopMatrix();

    glPopAttrib();
    glFlush();
    glutSwapBuffers();
}

/* the number of degrees to rotate the system at each click. */

GLfloat delta = 2.0;

void mouse(int btn, int state, int x, int y) {
    /* mouse callback, selects an axis about which to rotate */

    if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0;
    if(btn==GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) axis = 1;
    if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 2;
    theta[axis] += delta;
    if( theta[axis] > 360.0 ) theta[axis] -= 360.0;
    glutPostRedisplay();
}

void key(unsigned char k, int xx, int yy) {
    switch(k) {
    case 'q': exit(0); break;
    case '+': delta = +2.0; break;
    case '-': delta = -2.0; break;
    case '!': delta = -delta; break;
    }
}

void myReshape(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h) {
        GLfloat ar = (GLfloat) h / (GLfloat) w; /* aspect ratio */
        glOrtho(-2, 2, -2 * ar, 2 * ar, -10, 10);
    } else {
        GLfloat ar = (GLfloat) w / (GLfloat) h; /* aspect ratio */
        glOrtho(-2 * ar, 2 * ar, -2, 2, -10, 10);
    }
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char **argv) {
    glutInit(&argc, argv);

    init_textures();

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow(argv[0]);
    glutReshapeFunc(myReshape);
    glutDisplayFunc(display);
    glutMouseFunc(mouse);
    glutKeyboardFunc(key);
    glEnable(GL_DEPTH_TEST);
    glutMainLoop();
    return 0;
}