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


// watermark
#pragma comment(exestr, "(C)2001-2002 by Stephan Brumme")


// my parent's GPU driver is much too slow ... definitely !!!
//#define DONT_DRAW


static double PI = 3.1415926;
static double INTERSECTION_OFFSET = 0.0001;
static Color  clrBackground(0.05, 0.05, 0.1);
inline double frand() { return double(rand()) / (RAND_MAX); }

//
//  CGRayTracer Application
//


CGRayTracer::CGRayTracer(unsigned int x, unsigned int y) {
   
	// general settings
	// use shadows ?
	shadows_ = true;
	// recursion depth
	maxDepth_ = 7;
	// no. of intersection tests
	nTests_ = 0;
	// initial detail level (no. of pixels per ray)
	detail_ = 1<<8;
	antialias_ = false;

	// allocate memory to store the image
	imagex_ = x;
	imagey_ = y;
	image_  = new Color[(imagex_+1)*(imagey_+1)];
	for (unsigned int i=0; i<imagey_; i++)
		for (unsigned int j=0; j<imagex_; j++)
			image_[i*imagex_+j] = Color(-0.1,0,0);

	// number of shapes
    shapeSize_ = 0; // incremented by AddObject

    // create shape and material array
    shape_ = new Shape*[100];   
    material_ = new Material*[100];



	// background
	AddObject(new Box(Vector(-1000, -1000, 4), Vector(1000, 1000, 4.1)),
		      new Material (0.2, 0.5, 0.0, 10, 1, 1, Color(0.5,0.5,0.9)));

	// lower surface
	AddObject(new Box(Vector(-1, -0.1, -1), Vector(1, 0, 1)),
		      new Material (0.2, 0.5, 0.8, 10, 1, 1, Color(0.1,0.4,0.1)));

	// main sphere
	AddObject(new Sphere (Vector(0,0,0), 0.5), 
	          new Material (0.2, 0.5, 0.7, 32, 0.3, 1, Color(0.9,0.9,0.9)));

	// pyramid
	AddObject(new Triangle(Vector(0, 0, -0.4), Vector(0.4, 0, 0), Vector(0, 0.4, 0)),
	          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));
	AddObject(new Triangle(Vector(0, 0, -0.4), Vector(-0.4, 0, 0), Vector(0, 0.4, 0)),
	          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));
	AddObject(new Triangle(Vector(0, 0, +0.4), Vector(0.4, 0, 0), Vector(0, 0.4, 0)),
	          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));
	AddObject(new Triangle(Vector(0, 0, +0.4), Vector(-0.4, 0, 0), Vector(0, 0.4, 0)),
	          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));

	// sphere on top of the pyramid
	AddObject(new Sphere (Vector(0,0.45,0), 0.08), 
	          new Material (0.2, 0.5, 0.99, 32, 1, 1, Color(1.0,0.3,0.3)));

	// two arcs
	const int ARCSIZE = 14;
	for (i=0; i<ARCSIZE; i++)
	{
		const double arc_angle = ((i+0.5)*180.0 / (ARCSIZE-1)) * PI/180;

		// arc 1
		AddObject(new Sphere (Vector(+cos(arc_angle)*0.6, sin(arc_angle)*0.8, cos(arc_angle)*0.6), 0.05), 
		          new Material (0.2, 0.5, 0.7, 32, 0.3, 1.3, Color(0.8,0.8,0.8)));
		AddObject(new Sphere (Vector(+cos(arc_angle)*0.6, sin(arc_angle)*0.8, cos(arc_angle)*0.6), 0.01), 
		          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));

		// arc 2
		AddObject(new Sphere (Vector(-cos(arc_angle)*0.6, sin(arc_angle)*0.8, cos(arc_angle)*0.6), 0.05), 
		          new Material (0.2, 0.5, 0.7, 32, 0.3, 1.3, Color(0.8,0.8,0.8)));
		AddObject(new Sphere (Vector(-cos(arc_angle)*0.6, sin(arc_angle)*0.8, cos(arc_angle)*0.6), 0.01), 
		          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));
	}

	// ring
	const int RINGSIZE = 25;
	for (i=0; i<RINGSIZE; i++)
	{
		const double ring_angle = (i * 360 / RINGSIZE) * PI/180;
		AddObject(new Sphere (Vector(cos(ring_angle)*0.5, 0.07, sin(ring_angle)*0.5), 0.03), 
		          new Material (0.2, 0.5, 0.9, 32, 1, 1, Color(0.2,0.2,0.2)));
	}


	// set camera
    camera_ = new Camera(Vector(0.4, 2, -2), // from 
                         Vector(0, 0, 0) , // to
                         Vector(0, 1, 0),  // up
                         90);              // fov

    // set light sources
    lightSize_ = 2;
    light_ = new Light*[lightSize_];
    light_[0] = new Light( Vector(2, 2.3, -1.5), 0.4, 0.1 );
	light_[1] = new Light( Vector(-1, 1, -1.5), 0.6, 0.1 );


	// INITIAL TEST SCENE, NOT USED ANYMORE !!!

	// main sphere
/*	AddObject(new Sphere (Vector(0,0,0), 0.4), 
	          new Material (0.2, 0.5, 0.7, 32, 0.3, 1, Color(0.8,0.8,0.8)));
	AddObject(new Sphere (Vector(0,0.1,0), 0.1), 
	          new Material (0.2, 0.5, 0.7, 32, 1, 1, Color(0.8,0.8,0.8)));

	// upper right sphere
//	AddObject(new Sphere (Vector(0.5,0.5,-0.5), 0.15),
//		      new Material (0.2, 0.6, 0.8, 100, 0.5, 1.3, Color(0.6,0.6,1.0)));

	// ground
	AddObject(new Box (Vector(-0.7,-0.2,-0.7), Vector(0.7,-0.15,0.7)),
		      new Material (0.2, 0.5, 0.5, 10, 1, 1, Color(0.5,0.5,0.9)));
	
	// upper right box
	AddObject(new Box (Vector(-0.05,0.3,-0.6), Vector(0.1,0.4,-0.4)),
		      new Material (0.2, 0.5, 0.5, 10, 1, 1, Color(0.5,0.9,0.5)));

	// upper box
	AddObject(new Box (Vector(-0.25,0.3,-0.4), Vector(-0.15,0.7,-0.3)),
		      new Material (0.2, 0.3, 0.5, 10, 1, 1, Color(0.5,0.5,0.5)));

	// back plane
	AddObject(new Triangle(Vector (-2, -2, 0.7), Vector ( 2,  1.8, 0.7), Vector ( 2, -2, 0.7)),
              new Material (0.2, 0.3, 0.7, 10, 1, 1, Color(0.5,0.5,0.5)));

	// bottom plane
	AddObject(new Box (Vector(-1, -1, -1), Vector(1,-0.9,1)),
		      new Material (0.2, 0.3, 0.5, 10, 1, 1, Color(0.8,0.5,0.5)));
	AddObject(new Triangle(Vector(-0.8, -0.5, -1), Vector(0.8,-0.5,1), Vector(0.8,-0.5,-1)),
		      new Material (0.2, 0.3, 0.5, 10, 1, 1, Color(0.5,0.9,0.5)));

	// mid-scene triangles
	AddObject(new Triangle(Vector (0.4, -0.1, -0.6), Vector (0.6, -0.1, -0.6), Vector (0.6, -0.1, -0.4)),
              new Material (0.2, 0.3, 0.7, 10, 0.8, 1, Color(0.5,0.9,0.5)));
	AddObject(new Triangle(Vector (0.5, 0.0, -0.7), Vector (0.7, 0.0, -0.7), Vector (0.7, 0.0, -0.5)),
              new Material (0.2, 0.3, 0.7, 10, 0.5, 1, Color(0.5,0.9,0.5)));

	// back plane
//	AddObject(new Box(Vector(-2, -2, 1.2), Vector(2, 2, 1.3)),
//		      new Material (0.1, 0.2, 0.6, 50, 1, 1, Color(0.9,0.9,0.9)));

	// sphere on da right side
	AddObject(new Sphere (Vector(0.6,-0.05,-0.1), 0.05),
		      new Material (0.2, 0.2, 0.8, 100, 1, 1, Color(1,0.5,0.5)));
*/
}


CGRayTracer::~CGRayTracer() {    
    // clean up
    for (int i = 0; i < shapeSize_; i++) {
        delete shape_[i];
        delete material_[i];
    }
    for (int j = 0; j < lightSize_; j++) {
        delete light_[j];    
    }

    delete[] shape_;
    delete[] material_;
    delete[] light_;
}

void CGRayTracer::AddObject(Shape* shape, Material* material)
{
	shape_[shapeSize_] = shape;
	material_[shapeSize_] = material;

	shapeSize_++;
}

inline double max(double x, double y) {
	return (x<y) ? y : x;
}
inline double min(double x, double y) {
	return (x>y) ? y : x;
}

Color CGRayTracer::phongIlluminationColor(const Vector& point, const Vector& normal, Material* material) {
    // calculate Phong illumination

	// code is a slightly modified copy of my Phong homework

	// define intensity variables
	double dIntensityAmbient  = 0;
	double dIntensityDiffuse  = 0;
	double dIntensitySpecular = 0;

	// N = normal
	const Vector N_norm = normal.normalized();
	// V = view vector
	const Vector V = camera_->from - point;
	const Vector V_norm = V.normalized();

	// process all light sources 
	for (int nLight=0; nLight < lightSize_; nLight++)
	{
		// get a single light source
		const Light* const light = light_[nLight];

		// ALWAYS ambient intensity, even if shadowed
		dIntensityAmbient  += light->ambient;

		// L = light vector
		const Vector L = light->pos - point;
		const Vector L_norm = L.normalized();

		// N*L
		const double NdotL = dotProduct(N_norm, L_norm);

		// intensity reaching the surface (attenuation)
		const double dLightDistance = abs(L);
		double dMaxIntensity = 1.0 / (light->att_constant + dLightDistance*light->att_linear 
			                             + dLightDistance*dLightDistance*light->att_quadric);
		if (dMaxIntensity > 1)
			dMaxIntensity = 1;

		// get shadow
		if (shadows_)
		{
			// shadow ray must not start at the object's surface !
			// (else we get in trouble with intersection problems)
			const Ray shadowray(point+(light->pos - point)*INTERSECTION_OFFSET, light->pos - point);
			bool shadow = false;

			Shape** ppShape = shape_;
			for (int shape=0; shape<shapeSize_; shape++)
			{
				// get values of each intersection
				double distance;
				static Vector _normal, _point;

				// does the ray intersect the object ?
				shadow = shape_[shape]->intersect(shadowray, _point, _normal, distance);
				nTests_++;

				// intersection between light source and surface point ?
				if (shadow && distance < dLightDistance)
				{
					dMaxIntensity *= 1-material_[shape]->opacity;
					if (dMaxIntensity > 0.01)
						shadow = false;
					else
						// 100% shadow
						break;
				}
			}
			// shadowed ! no diffuse or specular light possible
			if (shadow)
				continue;
		}

		// R*V = (2*N*(N*L)-L)*V
		const double RdotV = max(dotProduct((2*NdotL*N_norm - L_norm).normalized(), V_norm), 0);

		// diffuse intensity
		dIntensityDiffuse  += dMaxIntensity * material->kd * NdotL;
		// specular intensity
		dIntensitySpecular += dMaxIntensity * material->ks * pow(RdotV, material->n);
	}

	// return clamped color
	return material->color * min(dIntensityAmbient+dIntensityDiffuse+dIntensitySpecular,1);
}

Color CGRayTracer::rayTrace(const Ray& r, int nDepth) {
    // Check each shape for intersektion.
    // Return phong color of nearest shape 
    // that is hit.

	if (nDepth++ > maxDepth_)
		return clrBackground;

	// shape that we found
	int closestShape = -1;
	// its parameters
	double closestDistance = 99999999;
	Vector closestPoint;
	Vector closestNormal;

	Shape** ppShape = shape_;
	for (int shape=0; shape<shapeSize_; shape++)
	{
		// get values of each intersection
		double distance;
		static Vector normal;
		static Vector point;

		// internal counter
		nTests_++;

		// does the ray intersect the object ?
		if (shape_[shape]->intersect(r, point, normal, distance))
			// closer than any intersection we tested before ?
			if (distance < closestDistance)
			{
				closestDistance = distance;
				closestShape    = shape;
				closestPoint    = point;
				closestNormal   = normal;
			}
	}

	// no intersection found
	if (closestShape < 0)
		return clrBackground;
	Material& material = *(material_[closestShape]);

	
	// object itself
	Color color = phongIlluminationColor(closestPoint, closestNormal, &material);

	// reflection
	if (material.ks >= 0.001)
	{
		// get reflected ray
		double reflected_angle     = -dotProduct(closestNormal, r.getDirection());
		if (reflected_angle < 0)
		{
			closestNormal   *= -1;
			reflected_angle *= -1;
		}

		const Vector reflected_direction = r.getDirection() + 2*reflected_angle*closestNormal;

		// reflected ray must not start at the object's surface !
		// (else we get in trouble with intersection problems)
		const Ray reflected_ray(closestPoint+closestNormal*INTERSECTION_OFFSET, 
			                    reflected_direction, material.lightspeed);

		// get color
		const Color reflected_color = rayTrace(reflected_ray, nDepth) * material.ks * material.opacity;

		// add reflective part
		color += reflected_color;
	}

	// refraction
	if (material.opacity < 1)
	{
		double lightspeedratio = r.getLightspeed() / material.lightspeed;

		double refracted_angle     = -dotProduct(closestNormal, r.getDirection());
		if (refracted_angle < 0)
		{
			closestNormal   *= -1;
			lightspeedratio = 1/lightspeedratio;
		}

		// compute refraction vector (its direction)
		const Vector L       = -r.getDirection();
		const double NdotL   = dotProduct(closestNormal, L);
		// Snell's Law (splitted up for better readibility)
		const double Root    = 1 - lightspeedratio*lightspeedratio*(1 - NdotL*NdotL);
		const double Bracket = lightspeedratio*NdotL - sqrt(Root);
		const Vector T       = Bracket*closestNormal - lightspeedratio*L;

		// slight shift of new ray origin
		Vector T_origin      = closestPoint;
		if (NdotL < 0)
			T_origin += closestNormal*10*INTERSECTION_OFFSET;
		else
			T_origin -= closestNormal*10*INTERSECTION_OFFSET;

		const Ray refracted_ray(T_origin, T, material.lightspeed);
								//r.getDirection(), material.lightspeed);
		
		// get color
		const Color refracted_color = rayTrace(refracted_ray, nDepth) * (1-material.opacity);

		// add reflective part
		color *= material.opacity;
		color += refracted_color;
	}

	// clamp color
	color[0] = min(color[0], 1);
	color[1] = min(color[1], 1);
	color[2] = min(color[2], 1);
//	color[0] = max(color[0], 0);
//	color[1] = max(color[1], 0);
//	color[2] = max(color[2], 0);

	return color;
}

void CGRayTracer::writePPMPixel(const Color& c) {
    // write pixel to file
    (*out_) << ((unsigned char)(c[0]*255))
            << ((unsigned char)(c[1]*255))
            << ((unsigned char)(c[2]*255));
}
    
void CGRayTracer::writeImage(char* fileName) {

	cout << "saving " << fileName << " - ";
    // create output stream
    out_ = new ofstream(fileName);

    // write PPM header
#ifdef _MSC_VER
    (*out_) << binary; 
#endif
    (*out_) << "P6" << endl 
            << width_ << " " << height_ << endl
            << 255 << endl;
   
	// write all pixel
	for(unsigned int i=0; i<imagey_; i++) 
		for(unsigned int j=0; j<imagex_; j++) 
			writePPMPixel(image_[i*imagex_+j]);

    // delete output stream
    delete out_;

	cout << "done." << endl;
}


void CGRayTracer::createImage(int width, int height) {
	// convert field-of-view angle to rad
	const double fovy_rad = camera_->fovy * PI/180;

	// look vector
	const Vector Look  = camera_->to - camera_->from;

	// delta angles
	const double up_angle_delta    = fovy_rad / height;
	const double right_angle_delta = fovy_rad / height;//width;

	// normalized vectors that describe the view plane (right handed !)
	const Vector Right = camera_->up.normalized() * Look.normalized();
	const Vector Up    = Right * Look.normalized();

	// image
	const double widthoffset  = imagex_/(double)width;
	const double heightoffset = imagey_/(double)height;
	const double pixelsize = detail_;

	for(int i=0; i<height; i++)
	{
		for(int j=0; j<width; j++) 
		{
		    // create rays for each pixel and send through scene

			// skip if already calculated
			const int truex = int(j*widthoffset);
			const int truey = int(i*heightoffset);
			Color& clrPixel = image_[truey*imagex_+truex];
			if (clrPixel[0] >= 0)
			{
				// draw already calculated pixels
#ifndef DONT_DRAW
				glColor3dv(clrPixel.rep());
				glRectd(truex, height_-truey, 
					    truex+pixelsize, height_-(truey+pixelsize));
#endif
				continue;
			}

			// angles
			const double up_angle    = (i-height/2.0) * up_angle_delta;
			const double right_angle = (j-width /2.0) * right_angle_delta;

			// correspending vectors
			const Vector CurrentUp    = Up    * abs(Look) * tan(up_angle);
			const Vector CurrentRight = Right * abs(Look) * tan(right_angle);

			// put it all together
			const Vector LookAt = Look + CurrentUp + CurrentRight;

			// ray tracing
			clrPixel = rayTrace(Ray(camera_->from, LookAt));

			// draw pixel
#ifndef DONT_DRAW
			glColor3dv(clrPixel.rep());
			glRectd(truex, height_-truey, 
				    truex+pixelsize, height_-(truey+pixelsize));
#endif
		}
	}
}


void CGRayTracer::onInit() {
	// no perspective drawing, just pure 2D display
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0, imagex_-1, 0, imagey_-1);

	glClearColor(clrBackground[0], clrBackground[1], clrBackground[2],1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // start timer
	start_ = clock();
}

void CGRayTracer::onSize(unsigned int newWidth,unsigned int newHeight) {          
    width_ = newWidth;
    height_ = newHeight;  
	
	glViewport(0,0, width_-1, height_-1);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	onDraw();
}

void CGRayTracer::onKey(unsigned char key) {
    switch (key) {
    case 27: { exit(0); break; }                        
	case 'a': antialias_ = !antialias_; onDraw(); break;
    }
}

void CGRayTracer::onIdle() {
	if (detail_ > 1)
	{
		// next detail level
		detail_ /= 2;
		createImage(imagex_ / detail_, imagey_ / detail_);

		if (detail_ > 1)
		{
			// detail level completed
			cout << detail_ << "x" << detail_ << " level done" << endl;
		}
		else
		{
			// stop timer
			clock_t finish = clock();
			cout << "... image completed !" << endl;

			writeImage("raytracer.ppm");
			
			double seconds = (finish - start_)/(double)CLOCKS_PER_SEC;
			// show some statistics
			cout << endl
				 << imagey_ << "x" << imagex_ << " pixels rendered using " << nTests_ << " intersection tests in " 
				 << seconds << " seconds" << endl
				 << "=> " << int(imagex_*imagey_/seconds) << " pixels/sec and " 
				 << nTests_/double(imagex_*imagey_) << " tests/pixel (ray depth=" << maxDepth_ << ")" << endl;

		}
	}
}

void CGRayTracer::onDraw() {
//    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// "pixel" size
	const double size = detail_;

	if (!antialias_ || detail_ > 1)
		// process all pixels
		for (unsigned int i=0; i<imagey_; i++)
			for (unsigned int j=0; j<imagex_; j++)
			{
				// draw only if already calculated
				const Color& color = image_[i*imagex_+j];
				if (color[0] >= 0)
				{
					glColor3dv(color.rep());
					glRectd(j, imagey_-i, j+size, imagey_-(i+size));
				}
			}
	else
		// process all pixels
		for (unsigned int i=0; i<imagey_; i++)
			for (unsigned int j=0; j<imagex_; j++)
			{
				if (i==0 || j==0)
				{
					glColor3dv(image_[i*imagex_+j].rep());
					glRectd(j, imagey_-i, j+size, imagey_-(i+size));
				}
				else
				{
					// weight neighbours
					const Color color = (image_[(i-1)*imagex_+j] +
										 image_[(i-1)*imagex_+j-1] +
										 image_[(i-1)*imagex_+j+1] +
									   4*image_[ i   *imagex_+j] +
										 image_[ i   *imagex_+j-1] +
										 image_[ i   *imagex_+j+1] +
										 image_[(i+1)*imagex_+j] +
										 image_[(i+1)*imagex_+j-1] +
										 image_[(i+1)*imagex_+j+1]) / 12;
					glColor3dv(color.rep());
					glRectd(j, imagey_-i, j+size, imagey_-(i+size));
				}
			}
}


// Hauptprogramm
int main(int argc, char* argv[]) {

	unsigned int maxx;
	unsigned int maxy;

	cout << "Bildformat bitte eingeben !" << endl
		 << "Breite: ";
	cin  >> maxx;
	cout << "Hoehe : ";
	cin  >> maxy;
	
    // Erzeuge eine Instanz der Beispiel-Anwendung:
    CGRayTracer sample(maxx, maxy);

    cout << endl
		 << "Tastenbelegung:" << endl
		 << "ESC        Programm beenden" << endl
//		 << "a          Antialiasing ein/aus" << endl
		 << endl
		 << "Das Bild wird automatisch unter \"raytracer.ppm\" gespeichert." << endl << endl;

    // Starte die Beispiel-Anwendung:
	
	sample.start("Stephan Brumme, 702544", false, maxx, maxy);

	return 0;
}