//FILE:  rt.cpp
//T.S. Garrett
//April 1, 2003
//Crude Ray Tracing program.  
//Recognize spheres that are defined by
//  - center
//  - radius
//  - color

#include <GL/glut.h>
#include <iostream>
#include <cmath>     //provides tan

class GLdoublePoint
{
  public:
  GLdouble x,y,z;
};

class GLdoubleVector
{
  public:
  GLdouble x,y,z;
};

class Color3
{
  public:
  GLfloat red, green, blue;
};

class Sphere
{
  public:
  GLdoublePoint center;
  GLdouble radius;
  GLdouble hit_time;
  Color3 color;
};

void display();
void init();
void findWallHitTimes();
void rayTracer();
void defineSpheres();
void findHitTimeSpheres();
void pickWinner();
void plotPoint(GLint x, GLint y);
void keyboard(unsigned char key, int x, int y);

//GLOBAL VARIABLES:
GLdoublePoint s;                  //position of the ray;
GLdoubleVector dir;               //direction of the ray;
double t_hit;                     //hit time
GLdoublePoint P;                  //hit point
Color3 color;                     //color of pixel
GLint numCols;                    //number of columns
GLint numRows;                    //number of rows
GLint numSpheres;                 //number of spheres
GLint WinW = 640, WinH = 480;     //window width and height
GLdouble H, W, N, theta, aspect;  //scene dimensions
Sphere sphere[5];                 //maximum of 5 spheres in the scene

int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize (WinW, WinH);
  glutInitWindowPosition (10, 10);
  glutCreateWindow ("Ray Traced Scene"); 
  glutDisplayFunc(display);
  glutKeyboardFunc(keyboard);
  init();
  glutMainLoop();
  return 0;
}

////////////////////////////////////////////////////////////////////////////////////
void init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glOrtho(0, WinW-1, 0, WinH-1, -1.0, 1.0);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  //Set up the camera:
  theta = 50;  
  theta = theta*3.14159/180.0; 
  aspect = (double)WinW/(double)WinH;
  N = 5.0;
  H = N * tan(theta/2.0); 
  W = H * aspect; 
  s.x = 0.0;  s.y = 0.0;  s.z = N;  //Eye Position:
  
  numCols = WinW;  
  numRows = WinH;
  numSpheres = 1;
}

///////////////////////////////////////////////////////////////////////////////////////////

void display()
{
  
  glClear(GL_COLOR_BUFFER_BIT);
  defineSpheres();
  rayTracer();
  glFlush();
}

///////////////////////////////////////////////////////////////////////////////////////////

void shadePixel(GLint x, GLint y)
{
  glBegin(GL_POINTS);
    glVertex2i(x, y);
  glEnd();
  glFlush();    
}

///////////////////////////////////////////////////////////////////////////////////////////
void defineSpheres()
{
  sphere[0].center.x = 0.0;  sphere[0].center.y = 0.0;  sphere[0].center.z = 0.0;
  sphere[0].radius = 1.0;
  sphere[0].color.red = 1.0;  sphere[0].color.green = 0.0;  sphere[0].color.blue = 0.0;

}

///////////////////////////////////////////////////////////////////////////////////////////
void findHitTimeSpheres()
{
  int i;
  double scale, A, B, C, disc, time1, time2, length;
  GLdoubleVector local_dir;
  GLdoublePoint local_s;
  for(i=0; i<numSpheres; i++)
  {
    sphere[i].hit_time = -1.0;
    
    //inverse transform the ray:
    scale = 1.0/sphere[i].radius;
    local_s.x = scale*(s.x - sphere[i].center.x);  
    local_s.y = scale*(s.y - sphere[i].center.y);
    local_s.z = scale*(s.z - sphere[i].center.z);
    
    local_dir.x = dir.x*scale;
    local_dir.y = dir.y*scale;
    local_dir.z = dir.z*scale;
  //  cout<<"Transformed Ray: ("<<local_s.x<<","<<local_s.y<<","<<local_s.z<<") + ("<<local_dir.x<<","<<local_dir.y<<","<<local_dir.z<<")t"<<endl;

    A = local_dir.x*local_dir.x + local_dir.y*local_dir.y + local_dir.z*local_dir.z;
    B = local_s.x*local_dir.x + local_s.y*local_dir.y + local_s.z*local_dir.z;
    C = (local_s.x*local_s.x+local_s.y*local_s.y+ local_s.z*local_s.z) - 1.0;
    disc = B*B - A*C;
    if (disc <0)   //did not hit
      sphere[i].hit_time = -1;
    else
      if ((disc - 0.0)< 0.00005)  //hit one time
        sphere[i].hit_time = (-B + sqrt(disc))/A;
      else  //hit two times
      {
        time1 = (-B + sqrt(disc))/A;
        time2 = (-B - sqrt(disc))/A;
        if ((time1>0) && (time2>0))   //both positive hits
        {
          if (time1<time2)
            sphere[i].hit_time = time1;
          else
            sphere[i].hit_time = time2;
        }
        else  //at least one negative hit
        {
          if ((time2>0) && (time1<0))
             sphere[i].hit_time = time2;
          else
            if ((time1>0) && (time2<0))
             sphere[i].hit_time = time1;
            else  //both negative;
               sphere[i].hit_time = -2.0;  
        }
      }        
  }
}

///////////////////////////////////////////////////////////////////////////////////////////
void pickWinner()
{
  t_hit = 10000;
  color.red = 0.0;  color.green = 0.2;  color.blue = 0.0;
  int i;
  for (i=0; i<numSpheres; i++)
  {
   // cout<<sphere[i].hit_time<<endl;
    if ((sphere[i].hit_time>0.0) && (sphere[i].hit_time<t_hit))
    {
      color.red = sphere[i].color.red;  
      color.green = sphere[i].color.green;  
      color.blue = sphere[i].color.blue;
      t_hit = sphere[i].hit_time;
    }
  }
}
////////////////////////////////////////////////////////////////////////////////////////////
void rayTracer()
{
  int r,c, i;
  double col_const = 2.0/(double)numCols;
  double row_const = 2.0/(double)numRows;
  GLdouble row_dir;

  dir.z = -N;
  for(r=0; r<numRows; r++)
  {
    dir.y = (2.0*r/(double)numRows - 1)*H;
    for(c=0; c<numCols; c++)
    {
      dir.x = (2.0*c/(double)numCols - 1)*W;
      findHitTimeSpheres();
      pickWinner();
      glColor3f(color.red, color.green, color.blue);
      shadePixel(c,r);
    }
  }
}

///////////////////////////////////////////////////////////////////////////////////////////
void keyboard(unsigned char key, int x, int y)
{
  int i;
  switch(key)
  {
    case 'q':  
       exit(0);
       break;
    case 27:        // ESC key
       exit(0);
       break;

   }
}