#include <iostream>
using namespace std;
#include <math.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

#include <time.h>
#include <stdlib.h>

void display(void);
void animate(void);
void mouse(int button, int state, int x, int y);

struct square
{
  float c1[2];
  float c2[2];
  float velocity[2];
  float rgb[3];
} sq[500];

struct colormaster
{
  bool rgb[3];
} colors;

int main(int argc,char *argv[])
{
  glutInit(&argc, argv);	// initializes GLUT and processes any command line arguments
	                        // Note: glutInit() should be called before any other GLUT routine
  
  for (int i=0;i<3;i++)
    if (rand() % 2) 
      colors.rgb[i] = true;
    else 
      colors.rgb[i] = false;

  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);  //chooses double buffered and RGBA mode
  glutInitWindowPosition(10, 10);    //specifies the upper-left corner of window (with respect to screen)
  glutInitWindowSize(700, 700);		      //specifies the size, in pixels, of window
  
  glutCreateWindow("Screensaver!");		//creates a window of name given by input string
  glClearColor (0, 0, 0, 0);			//set clear window color black
  glShadeModel (GL_FLAT);
  
  glutDisplayFunc(display);		//registers display callback function, which is display()
  glutIdleFunc(animate);
  glutMouseFunc(mouse);
  
  glutMainLoop();
  
  return 0;
}

void display(void)
{
  int num = 500;
  glClear(GL_COLOR_BUFFER_BIT); // clear the buffer background color

  for (int k=0;k<num;k++)
  {
    sq[k].c1[0] = sq[k].c1[1] = -.1;
    sq[k].c2[0] = sq[k].c2[1] = .1;
    sq[k].velocity[0] = (double)((rand())/(RAND_MAX+1.0)/100);
    sq[k].velocity[1] = (double)((rand())/(RAND_MAX+1.0)/100);
    if ((sq[k].velocity[0] + sq[k].velocity[1]) < .004) 
      if (rand() % 2) 
	sq[k].velocity[1] += .002;
      else
	sq[k].velocity[0] += .002;
    if (rand() % 2) sq[k].velocity[0] *= -1;
    if (rand() % 2) sq[k].velocity[1] *= -1;
    for (int i=0;i<3;i++)
      if (colors.rgb[i])
	sq[k].rgb[i] = 1;
      else
	sq[k].rgb[i] = 0;
  }

  glPushMatrix();
  glColor3f(1,1,1);
  for (int k=0;k<num;k++)
    glRectf(sq[k].c1[0], sq[k].c1[1], sq[k].c2[0], sq[k].c2[1]);
  glPopMatrix();
  
  glutSwapBuffers();
}

void animate(void) 
{
  int num = 500;
  for (int k=0;k<num;k++)
  {
    // this code creates bouncing squares
    /*
    bool swap = false;
    if (sq[k].c1[0] <= -1 || sq[k].c2[0] >= 1)
      {
	sq[k].velocity[0] *= -1;
	swap = true;
      }
    if (sq[k].c1[1] <= -1 || sq[k].c2[1] >= 1)
      {
	sq[k].velocity[1] *= -1;
	swap = true;
      }

    if (swap) 
      {
	for (int i=0;i<3;i++)
	  if (colors.rgb[i])
	    sq[k].rgb[i] = (float)((rand())/(RAND_MAX+1.0));
	  else
	    sq[k].rgb[i] = 0;
      }
    */

    // this code creates perpetual square fountain
    if (sq[k].c2[0] <= -1 || sq[k].c1[0] >= 1 || sq[k].c2[1] <= -1 || sq[k].c1[1] >= 1)
      {
	sq[k].c1[0] = sq[k].c1[1] = -.1;
	sq[k].c2[0] = sq[k].c2[1] = .1;
	for (int i=0;i<3;i++)
	  if (colors.rgb[i])
	    sq[k].rgb[i] = (float)((rand())/(RAND_MAX+1.0));
	  else
	    sq[k].rgb[i] = 0;
      }
    
    sq[k].c1[0] += sq[k].velocity[0];
    sq[k].c1[1] += sq[k].velocity[1];
    sq[k].c2[0] += sq[k].velocity[0];
    sq[k].c2[1] += sq[k].velocity[1];
  }

  glClear(GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  for (int k=0;k<num;k++)
  {
    glColor3f(sq[k].rgb[0],sq[k].rgb[1],sq[k].rgb[2]);
    glRectf(sq[k].c1[0], sq[k].c1[1], sq[k].c2[0], sq[k].c2[1]);
  }
  glPopMatrix();
  glutSwapBuffers();
}

void mouse(int button, int state, int x, int y)
{
  switch (button) {
  case GLUT_LEFT_BUTTON:
    if (state == GLUT_DOWN)
      for (int i=0;i<3;i++)
	if (rand() % 2) 
	  colors.rgb[i] = true;
        else 
	  colors.rgb[i] = false;
    break;
  }
}