/* 
 * mandelbrot.c
 *
 * Mandelbrot set viewer
 */

#include <Windows.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

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

#include <malloc.h>

/* Global variables: view of the set */

GLint windW, windH;	/* size of the window on the screen */

/* Texture values */

#ifdef GL_VERSION_1_1
static GLuint texName;
#endif

#define TEXTURE_WIDTH  64
#define TEXTURE_HEIGHT 64

GLubyte Picture[TEXTURE_WIDTH][TEXTURE_HEIGHT][4];			/* Array of texels */

/* Objects to draw on */

GLUquadricObj *sphere;

double point[][3] = 
{{-1.0, -1.0, 1.0},
{1.0, -1.0, 1.0},
{1.0, 1.0, 1.0},
{-1.0, 1.0, 1.0},
{-1.0, -1.0, -1.0},
{1.0, -1.0, -1.0},
{1.0, 1.0, -1.0},
{-1.0, 1.0, -1.0}};

double normal[][3] = 
{{0.0, 0.0, 1.0},
{-1.0, 0.0, 0.0},
{0.0, -1.0, 0.0},
{1.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, 0.0, -1.0}};

int polygon[][4] = 
{{0, 1, 2, 3}, /* front faces */
{0, 3, 7, 4},
{0, 4, 5, 1}, /* back faces */
{1, 5, 6, 2},
{2, 6, 7, 3}, /* side faces */
{7, 6, 5, 4}};

/* Menu options */

enum {	CHOOSE_BOX,
		CHOOSE_SPHERE,
		CHOOSE_DECAL,
		CHOOSE_REPLACE,
		CHOOSE_MODULATE,
		CHOOSE_BLEND,
		CHOOSE_FLAT,
		CHOOSE_SMOOTH };

int shape = CHOOSE_BOX;
int mapping = GL_DECAL;
// int shading = GL_FLAT;

double yaw = 0;
double pitch = 0;
double dist = -5.0;

/* Initialization */

void Init(void) {
	/* Set background color */
    glClearColor(0.2, 0.8, 1.0, 0.0); /* blue sky */

	/* Generate a window */
	windW = 300;
	windH = 300;

	glutInitWindowPosition(0, 0); 
	glutInitWindowSize(windW, windH);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
    if (glutCreateWindow("Mandelbrot Texture") == GL_FALSE) {
		exit(1);
    }

	/* Create sphere for drawing on */
	if ((sphere = gluNewQuadric()) == NULL)
		exit(1);
	gluQuadricDrawStyle (sphere, GLU_FILL);
	gluQuadricNormals (sphere, GLU_FLAT);
	gluQuadricTexture (sphere, GL_TRUE);

	/* Enable shading and backface culling */
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glShadeModel(GL_FLAT);

	glEnable(GL_CULL_FACE);
	glCullFace(GL_BACK);

	/* Enable texture mapping */
	glEnable(GL_TEXTURE_2D);
}

/* Generate a texture */

void GenerateTexture(void) {

	/* Generate the texture map */
	int i, j;
	GLubyte r, g;

	for (j=0, r=255; j<TEXTURE_HEIGHT; j++, r -= 3) {
		for (i=0, g=255; i<TEXTURE_WIDTH; i++, g -= 3) {
			// Gradient
			//Picture[i][j][0] = r;
			//Picture[i][j][1] = g;
			//Picture[i][j][2] = 255 - r;

			// Checkerboard
			Picture[i][j][0] = (((i/8) + (j/8)) % 2) * 255;
			Picture[i][j][1] = 
			Picture[i][j][2] = 0;
			Picture[i][j][3] = 255;
		}
	}

	/* Define it as a texture map */

#ifdef GL_VERSION_1_1
   glGenTextures(1, &texName);
   glBindTexture(GL_TEXTURE_2D, texName);
#endif

	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, GL_LINEAR);
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, 
				  GL_RGBA, GL_UNSIGNED_BYTE, Picture);

	printf ("Done generating texture\n\n");
}

/* Draw the picture on the screen */

void Draw(void) {
	int i;

	/* clear the screen */
	glClear (GL_COLOR_BUFFER_BIT);

	/* Transformations */

	glLoadIdentity();
	glTranslatef(0.0, 0.0, dist);		/* step back */
	glRotatef(pitch, 1.0, 0.0, 0.0);	/* spin on X axis */
	glRotatef(yaw, 0.0, 1.0, 0.0);		/* spin on Y axis */

	/* Draw the textured surface */

	if (shape == CHOOSE_SPHERE) {
		gluSphere (sphere, 2.0, 20, 20);
	}

	else {

	/* Draw a box */
		for (i=0; i<6; i++) {
			glNormal3dv(normal[i]);
			glBegin(GL_POLYGON);
			glTexCoord2d(0.0, 0.0);
			glVertex3dv(point[polygon[i][0]]);
			glTexCoord2d(2.0, 0.0);
			glVertex3dv(point[polygon[i][1]]);
			glTexCoord2d(2.0, 2.0);
			glVertex3dv(point[polygon[i][2]]);
			glTexCoord2d(0.0, 2.0);
			glVertex3dv(point[polygon[i][3]]);
			glEnd();
		}
	}

	/* update the screen */

    glFlush();			/* force all changes to be applied to buffer */
	glutSwapBuffers();	/* display what you just drew */
}

/* Resize the picture */

void Resize(GLint width, GLint height) {
	float aspect;

    windW = (GLint)width;
    windH = (GLint)height;
	aspect = (float)windW / (float)windH;

	/* Viewport fills the entire window */

    glViewport(0, 0, width, height);

	/* Use perspective projection */
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective (60.0, aspect, 0.1, 100.0); /* fovy, aspect, near, far */

	/* Return to modelview mode */
    glMatrixMode(GL_MODELVIEW);
}

static void Key2(int key, int x, int y)
{
    switch (key) {
      case GLUT_KEY_LEFT:
		  yaw -= 1.0;
	break;
      case GLUT_KEY_RIGHT:
		  yaw += 1.0;
	break;
      case GLUT_KEY_UP:
		  pitch += 1.0;
	break;
      case GLUT_KEY_DOWN:
		  pitch -= 1.0;
	break;
      default:
	return;
    }

    glutPostRedisplay();
}

static void Key(unsigned char key, int x, int y)
{

    /* FILL IN CODE TO ZOOM IN OR OUT */

    switch (key) {
      case 27:
	exit(1);
      case '+':
		  dist += 1.0;
	break;
      case '-':
		  dist -= 1.0;
	break;
      default:
	return;
    }

    glutPostRedisplay();
}


/* Create pop-up window using GLUT */


void PopUp (int value)
{
	switch (value) {
		case CHOOSE_BOX:
			shape = value;
		break;
		case CHOOSE_SPHERE:
			shape = value;
		break;
		case CHOOSE_DECAL:
			mapping = GL_DECAL;
			glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mapping);
		break;
		case CHOOSE_REPLACE:
			mapping = GL_REPLACE;
			glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mapping);
		break;
		case CHOOSE_MODULATE:
			mapping = GL_MODULATE;
			glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mapping);
		break;
		case CHOOSE_BLEND:
			mapping = GL_BLEND;
			glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mapping);
		break;
		case CHOOSE_FLAT:
			gluQuadricNormals (sphere, GLU_FLAT);
			glShadeModel(GL_FLAT);
		break;
		case CHOOSE_SMOOTH:
			gluQuadricNormals (sphere, GLU_SMOOTH);
			glShadeModel(GL_SMOOTH);
		break;
		default:
			return;
	}

	glutPostRedisplay();
}

void initMenu(void)
{
	int shape_menuid, mapping_menuid, shading_menuid;

	/* create shape menu and save the id */
	shape_menuid = glutCreateMenu(PopUp);
	glutAddMenuEntry ("Draw Box", CHOOSE_BOX);
	glutAddMenuEntry ("Draw Sphere", CHOOSE_SPHERE);

	/* create a menu and save the id */
	mapping_menuid = glutCreateMenu(PopUp);
	glutAddMenuEntry ("Decal", CHOOSE_DECAL);
	glutAddMenuEntry ("Replace", CHOOSE_REPLACE);
	glutAddMenuEntry ("Modulate", CHOOSE_MODULATE);
	glutAddMenuEntry ("Blend", CHOOSE_BLEND);

	/* create a menu and save the id */
	shading_menuid = glutCreateMenu(PopUp);
	glutAddMenuEntry ("Flat", CHOOSE_FLAT);
	glutAddMenuEntry ("Smooth", CHOOSE_SMOOTH);

	/* create main menu */
	glutCreateMenu(PopUp);
	glutAddSubMenu ("Object Shape", shape_menuid);
	glutAddSubMenu ("Texture Mapping", mapping_menuid);
	glutAddSubMenu ("Shading", shading_menuid);

	/* attach menu to right button */
	glutAttachMenu (GLUT_RIGHT_BUTTON);
}

/* Print instructions */

void printInstructions()
{
	printf ("INSTRUCTIONS FOR USE\n\n");
	printf ("Click the right button for a pop-up menu\n");
	printf ("changing the object, texture mapping, and shading\n\n");
	printf ("Use the arrow keys to rotate the object\n\n");
	printf ("Use the '+' and '-' keys to zoom in and out\n\n");
}


/* Main program */

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

	Init();
	GenerateTexture();
	initMenu();
	printInstructions();

    glutReshapeFunc(Resize);
    glutKeyboardFunc(Key);
    glutSpecialFunc(Key2);
    glutDisplayFunc(Draw);
    glutMainLoop();
}