/*
 * 2D texturing demo using squares.  Based on an original demo by Michael
 * Sweet.
 *
 * Written by Scott D. Anderson, Fall 2001 */

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <tw.h>

/*
 * Globals...
 */

int win_width  = 500;                /* Width of window */
int win_height = 500;                /* Height of window */

GLint tex_width;                /* Width of texture */
GLint tex_height;                /* Height of texture */

GLint interpolation_mode;        // GL_NEAREST or GL_LINEAR

void checkError() {
    int err = glGetError();
    if( err == GL_NO_ERROR ) return;
    printf("error = 0x%4x\n",err);
}

/* Builds a 2d checkerboard of red and green squares, with whatever number
   of pixels per square you want. */

/* Function to create an array of pixels, alternating green and red, with
   the given number of pixels per square. Returns the array. */

GLubyte* init_checkerboard(int pixels_per_square) {
    int i,j;
    int pps = pixels_per_square;
    int bytes = pps*pps*64*3;
    GLubyte* checkerboard = (GLubyte*) malloc(bytes);
    /* The following is a red&green checkerboard.  It's done using a 1D
       array alternating colors. We change colors every pps. */
    int count=0;
    for(i=0;i<pps*8;++i) 
        for(j=0;j<pps*8;++j) {
            if((i&pps)^(j&pps)) {
                checkerboard[count++] = 255;
                checkerboard[count++] = 0;
                checkerboard[count++] = 0;
            } else {
                checkerboard[count++] = 0;
                checkerboard[count++] = 255;
                checkerboard[count++] = 0;
            }
        }
    if(bytes!=count) 
        printf("bytes = %d count = %d\n",bytes,count);
    return checkerboard;
}

void square(int pps) {
    GLubyte *TexBits = init_checkerboard(pps);
    glTexImage2D(GL_TEXTURE_2D,        /* target, always this value */
                 0,                /* level of detail; always zero */
                 3,                /* number of color components.  This is RGB color */
                 8*pps,                /* number of columns.  Must be a power of 2 */
                 8*pps,                /* number of rows.  Also a power of 2 */
                 0,                /* border width:  zero or one */
                 GL_RGB,        /* format of pixel data */
                 GL_UNSIGNED_BYTE, /* datatype of pixel data */
                 TexBits        /* pointer to texture (pixel) data */
                 );
    checkError();
    glScalef(0.9,0.9,1);
    glBegin(GL_POLYGON); {
        glTexCoord2f(0,0);        glVertex3f(-1,-1,0);
        glTexCoord2f(0,1);        glVertex3f(-1,+1,0);
        glTexCoord2f(1,1);        glVertex3f(+1,+1,0);
        glTexCoord2f(1,0);        glVertex3f(+1,-1,0);
    }
    glEnd();
}    

void alt_checks() {
    GLubyte checks[8][8][3];
    for(int i=0; i<8; i++) {
        for(int j=0; j<8; j++) {
            if((i+j)%2 == 0) {
                checks[i][j][0] = 255;
                checks[i][j][1] = 255;
                checks[i][j][2] = 0;
            } else {
                checks[i][j][0] = 0;
                checks[i][j][1] = 0;
                checks[i][j][2] = 255;
            }
        }
    }
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, interpolation_mode);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, interpolation_mode);
    glTexImage2D(GL_TEXTURE_2D,        /* target, always this value */
                 0,                /* level of detail; always zero */
                 3,                /* number of color components.  This is RGB color */
                 8,                /* number of columns.  Must be a power of 2 */
                 8,                /* number of rows.  Also a power of 2 */
                 0,                /* border width:  zero or one */
                 GL_RGB,        /* format of pixel data */
                 GL_UNSIGNED_BYTE, /* datatype of pixel data */
                 checks                /* pointer to texture (pixel) data */
                 );
    checkError();
    glEnable(GL_TEXTURE_2D);
    glScalef(0.9,0.9,1);
    glBegin(GL_POLYGON); {
        glTexCoord2f(0,0);        glVertex3f(-1,-1,0);
        glTexCoord2f(0,1);        glVertex3f(-1,+1,0);
        glTexCoord2f(1,1);        glVertex3f(+1,+1,0);
        glTexCoord2f(1,0);        glVertex3f(+1,-1,0);
    }
    glEnd();
}

/* Display a normal texture-mapped square in the center and variations
   around it. */

void display(void) {
    int i, j, pps;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    twCamera();

    /* added this, to make the squares stand out.  SDA */
    glClearColor(0.5,0.5,0.5,1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    /* Textures are decals */
    glEnable(GL_TEXTURE_2D);        /* use textures from now on */
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, interpolation_mode);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, interpolation_mode);

    glPushMatrix();
    glTranslatef(-1,-1,0);
    square(1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-1,+1,0);
    square(2);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(+1,-1,0);
    square(4);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(+1,+1,0);
    // alt_checks();
    square(4);
    glPopMatrix();

    glFlush();
}

void resize(int width, int height) {
    GLfloat half=2;
    /* compute aspect ratio */
    GLfloat ar = (GLfloat) width / (GLfloat) height;
    /* Save the new width and height */
    win_width  = width;
    win_height = height;

    /* Reset the viewport... */
    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (width <= height) {
        gluOrtho2D(-half * ar, half * ar, -half, half);
    } else {
        gluOrtho2D(-half, half, -half * ar, half * ar);
    }
}

int main(int  argc, char *argv[]) {
    int   tmpargc   = 1;
    char* tmpargv[] = {"-gldebug"};
    if(argc<2) {
        printf("Usage: %s L/N\nwhether to use linear or nearest\n",argv[0]);
        exit(0);
    } else if(argv[1][0] == 'L') {
        interpolation_mode = GL_LINEAR;
    } else if(argv[1][0] == 'N') {
        interpolation_mode = GL_NEAREST;
    } else {
        printf("Usage: %s L/N\nwhether to use linear or nearest\n",argv[0]);
        exit(0);
    }        
    glutInit(&tmpargc, tmpargv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH);
    glutInitWindowSize(win_width, win_height);
    glutCreateWindow(argv[0]);
    glutReshapeFunc(resize);
    glutDisplayFunc(display);
    twBoundingBox(-1,+1,-1,+1,-1,+1);
    twMainInit();
    glutMainLoop();
    return (0);
}