/* 
   
   Structure 3 
   
   A surface filled with one hundred medium to small sized circles. 
   Each circle has a different size and direction, but moves at the same slow rate. 
   Display: 
   A. The instantaneous intersections of the circles 
   >>> B. The aggregate intersections of the circles 
 
   Implemented by Casey Reas <http://groupc.net> 
   8 March 2004 
   C++ / OpenGL 
 
   Writing this program in C++ required three files: 
   s3_A.cpp     The controller file, opens/updates the window 
   Circle.cpp   Defines the behavior for the circles 
   Circle.h     Skematic information about the circles 
 
*/ 
 
 
 
#include <GL/glut.h> 
#include <stdlib.h> 
#include <math.h> 
#include "Circle.h" 
 
static GLfloat spin = 0.0; 
static GLint once = 1; 
 
static int width; 
static int height; 
 
Circle *circles[numCircle]; 
 
void display(void) 
{ 
     glClear(GL_COLOR_BUFFER_BIT); 
   
   for(int i=0; i<numCircle; i++) { 
     circles[i]->update(); 
     circles[i]->move(); 
   } 
 
   glutSwapBuffers(); 
   glutPostRedisplay(); 
} 
 
GLfloat random() { 
  return (GLfloat) ((float)(rand() >> 0) / 16384.0) - 1.0; 
} 
 
void init(void)  
{ 
   glEnable (GL_BLEND); 
   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
   glClearColor (1.0, 1.0, 1.0, 1.0); 
   glShadeModel (GL_FLAT); 
   GLfloat values[2]; 
   glGetFloatv (GL_LINE_WIDTH_GRANULARITY, values); 
   glGetFloatv (GL_LINE_WIDTH_RANGE, values); 
   glEnable (GL_LINE_SMOOTH); 
   glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE); 
   glLineWidth (0.5); 
   
   width = 1024; 
   height = 786; 
   
   for (int i=0; i<numCircle; i++) { 
     circles[i] = new Circle(random()*512, random()*384, 
                            (random() + 1) * 60, 
                             random()*0.25, random()*0.25, i, circles); 
   } 
} 
 
void reshape(int w, int h) 
{ 
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode(GL_PROJECTION); 
   glLoadIdentity(); 
   gluOrtho2D(-512.0, 512.0, -384.0, 384.0); 
   glMatrixMode(GL_MODELVIEW); 
   glLoadIdentity(); 
   glClear(GL_COLOR_BUFFER_BIT); 
} 
 
void mouse(int button, int state, int x, int y)  
{ 
   switch (button) { 
      case GLUT_LEFT_BUTTON: 
         break; 
      case GLUT_MIDDLE_BUTTON: 
      case GLUT_RIGHT_BUTTON: 
         break; 
      default: 
         break; 
   } 
} 
 
void keyboard(unsigned char c, int x, int y) { 
  if(c == 'q' || c == 'Q') { 
    exit(0); 
  } 
} 
   
/* 
 *  Request double buffer display mode. 
 *  Register mouse input callback functions 
 */ 
int main(int argc, char** argv) 
{ 
   glutInit(&argc, argv); 
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); 
   glutCreateWindow("Structure3"); 
   glutFullScreen(); 
   init (); 
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape); 
   glutMouseFunc(mouse); 
   glutKeyboardFunc(keyboard); 
   glutMainLoop(); 
   return 0;   /* ANSI C requires main to return int. */ 
} 
 
 
#include "Circle.h" 
 
Circle::Circle(float px, float py, float pr, float psp, float pysp, int pid, Circle *circles[numCircle]) 
{ 
    others = circles; 
    
    x = px; 
    y = py; 
    r = pr; 
    r2 = r*r; 
    id = pid; 
    sp = psp; 
    ysp = pysp; 
} 
 
void Circle::update() 
{ 
  for(int i=0; i<numCircle; i++) { 
    if(i != id) { 
      intersect( others[id], others[i] ); 
    } 
  } 
} 
 
 
void Circle::move() 
{ 
  x += sp; 
  y += ysp; 
  
  if(sp > 0) { 
    if(x > width/2+r) { 
      x = -width/2-r; 
    }   
  } else { 
    if(x < -width/2-r) { 
      x = width/2+r; 
    } 
  } 
  
  if(ysp < 0) { 
    if(y < -height/2-r) { 
      y = height/2+r; 
    } 
  } else { 
    if(y > height/2+r) { 
      y = -height/2-r; 
    } 
  } 
  
  glColor3f(0.0, 0.0, 0.0); 
  glBegin(GL_POINTS); 
  glVertex2f(x, y); 
  glEnd(); 
 
} 
 
void Circle::intersect(Circle *cA, Circle *cB) 
{ 
  float dx = cA->x - cB->x; 
  float dy = cA->y - cB->y; 
  float d2 = dx*dx + dy*dy; 
  float d = sqrt( d2 ); 
 
  if ( d>cA->r+cB->r || d<abs(cA->r-cB->r) ) return; // no solution 
 
  float a = (cA->r2 - cB->r2 + d2) / (2*d); 
  float h = sqrt( cA->r2 - a*a ); 
  float x2 = cA->x + a*(cB->x - cA->x)/d; 
  float y2 = cA->y + a*(cB->y - cA->y)/d; 
 
  float paX = x2 + h*(cB->y - cA->y)/d; 
  float paY = y2 - h*(cB->x - cA->x)/d; 
  float pbX = x2 - h*(cB->y - cA->y)/d; 
  float pbY = y2 + h*(cB->x - cA->x)/d; 
 
  float dist = 1.0 - distance(paX, paY, pbX, pbY) *2 / 255.0f; 
  glColor4f(dist, dist, dist, 1.0); 
 
  glBegin(GL_LINES); 
  glVertex2f(paX, paY); 
  glVertex2f(pbX, pbY); 
  glEnd(); 
 
} 
 
float Circle::distance(float x1, float y1, float x2, float y2) { 
	return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)); 
} 
 
 
 
#include "math.h" 
#include <GL/glut.h> 
 
#ifndef _Circle_H_ 
#define _Circle_H_ 
 
#define PI 3.14159265358979323846 
#define TWO_PI 6.28318530717958647693 
#define numCircle 100 
 
class Circle 
{ 
public: 
  
  float x, y, r, r2, sp, ysp; 
  int id; 
 
  Circle **others; 
 
  Circle(); 
  Circle(float, float, float, float, float, int, Circle *[numCircle]); 
  void update(); 
  void move(); 
  void intersect(Circle *, Circle *); 
  float distance(float, float, float, float); 
 
}; 
 
#endif