//torussphere2
//  Z-Buffer
//  This method improves the error in "torussphere1".
// T. Kosaka CS TNCT 2001

#include <stdio.h>
#include <math.h>
#include <GL/glut.h>
#include "drawtools3D.h"
#ifndef M_PI
#define M_PI 3.141592653589793
#endif

#define MAXSIZE 8192

int interpolateInteger(int p1,int p2,float s1,float s2)
{
	if (s1<0.) s1=0.;
	if (s2<0.) s2=0.;
	if (s1+s2<1.) return p1;
	return (int)((p1*s2+p2*s1)/(s1+s2)+.5);
}

float interpolateFloat(float p1,float p2,float s1,float s2)
{
	if (s1<0.) s1=0.;
	if (s2<0.) s2=0.;
	if (s1+s2<1.) return p1;
	return (p1*s2+p2*s1)/(s1+s2);
}

color_t interpolateColor(color_t c1,color_t c2,float s1,float s2)
{
	color_t ret;
	if (s1<0.) s1=0.;
	if (s2<0.) s2=0.;
	if (s1+s2<1.) {
		ret=c1;
	} else {
		ret.r=(1./(s1+s2))*(c1.r*s2+c2.r*s1);
		ret.g=(1./(s1+s2))*(c1.g*s2+c2.g*s1);
		ret.b=(1./(s1+s2))*(c1.b*s2+c2.b*s1);
	}
	return ret;
}

void drawDot(float x,float y)
{
	glBegin(GL_POINTS);
		glVertex2f(x,y);
	glEnd();
}

void fillPolygonZBuff(point3D_t pnt[],int num,color_t color,float zbuffer[640][480])
{
	int top,bottom;
	int topleft,topright,bottomleft,bottomright;
	int ymax,ymin,xleft,xright;
	float zleft,zright,z;
	int i,y,x;
	top=0,bottom=0;
	for(i=0;i<num;i++) {
		if (pnt[top].y<pnt[i].y) top=i;
		if (pnt[i].y<pnt[bottom].y) bottom=i;
	}
	ymax=(int)(pnt[top].y+0.5);
	ymin=(int)(pnt[bottom].y+0.5);
	bottomleft=bottomright=bottom;
	topleft=(bottomleft-1+num)%num;
	topright=(bottomright+1)%num;
	setColor(color);
	for (y=ymin;y<=ymax;y++) {
		if ((int)(pnt[topleft].y+0.5)<y) {
			bottomleft=topleft;
			topleft=(bottomleft-1+num)%num;
		}
		if ((int)(pnt[topright].y+0.5)<y) {
			bottomright=topright;
			topright=(bottomright+1)%num;
		}
		xleft=interpolateInteger((int)pnt[topleft].x,(int)pnt[bottomleft].x,pnt[topleft].y-y,y-pnt[bottomleft].y);
		xright=interpolateInteger((int)pnt[topright].x,(int)pnt[bottomright].x,pnt[topright].y-y,y-pnt[bottomright].y);
		zleft=interpolateFloat(pnt[topleft].z,pnt[bottomleft].z,pnt[topleft].y-y,y-pnt[bottomleft].y);
		zright=interpolateFloat(pnt[topright].z,pnt[bottomright].z,pnt[topright].y-y,y-pnt[bottomright].y);
		for (x=xleft;x<=xright;x++) {
			z=interpolateFloat(zright,zleft,xright-x,x-xleft);
			if ((z>zbuffer[x+320][y+240])&&(-320<=x)&&(x<320)&&(-240<=y)&&(y<240)) {
				drawDot(x,y);
				zbuffer[x+320][y+240]=z;
			}
		}
	}
}

void gradatePolygonZBuff(point3D_t pnt[],color_t col[],int num,float zbuffer[640][480])
{
	int top,bottom;
	int topleft,topright,bottomleft,bottomright;
	int ymax,ymin,xleft,xright;
	float zleft,zright,z;
	color_t colorleft,colorright,color;
	int i,y,x;
	top=0,bottom=0;
	for(i=0;i<num;i++) {
		if (pnt[top].y<pnt[i].y) top=i;
		if (pnt[i].y<pnt[bottom].y) bottom=i;
	}
	ymax=(int)(pnt[top].y+0.5);
	ymin=(int)(pnt[bottom].y+0.5);
	bottomleft=bottomright=bottom;
	topleft=(bottomleft-1+num)%num;
	topright=(bottomright+1)%num;
	for (y=ymin;y<=ymax;y++) {
		if ((int)(pnt[topleft].y+0.5)<y) {
			bottomleft=topleft;
			topleft=(bottomleft-1+num)%num;
		}
		if ((int)(pnt[topright].y+0.5)<y) {
			bottomright=topright;
			topright=(bottomright+1)%num;
		}
		xleft=interpolateInteger((int)pnt[topleft].x,(int)pnt[bottomleft].x,pnt[topleft].y-y,y-pnt[bottomleft].y);
		xright=interpolateInteger((int)pnt[topright].x,(int)pnt[bottomright].x,pnt[topright].y-y,y-pnt[bottomright].y);
		zleft=interpolateFloat(pnt[topleft].z,pnt[bottomleft].z,pnt[topleft].y-y,y-pnt[bottomleft].y);
		zright=interpolateFloat(pnt[topright].z,pnt[bottomright].z,pnt[topright].y-y,y-pnt[bottomright].y);
		colorleft=interpolateColor(col[topleft],col[bottomleft],pnt[topleft].y-y,y-pnt[bottomleft].y);
		colorright=interpolateColor(col[topright],col[bottomright],pnt[topright].y-y,y-pnt[bottomright].y);
		for (x=xleft;x<=xright;x++) {
			z=interpolateFloat(zright,zleft,xright-x,x-xleft);
			if ((z>zbuffer[x+320][y+240])&&(-320<=x)&&(x<320)&&(-240<=y)&&(y<240)) {
				color=interpolateColor(colorleft,colorright,x-xleft,xright-x);
				setColor(color);
				drawDot(x,y);
				zbuffer[x+320][y+240]=z;
			}
		}
	}
}

//////////// End of OpenGL drawShape Functions ver 2 ////////////

void userdraw(void);

void display(void)
{
	glClear( GL_COLOR_BUFFER_BIT);
	userdraw();
	glutSwapBuffers();
}

//////////////////////////////////////////////////////////////////
void drawcharX(float x,float y)
{
	drawLine(x,y,x+10,y+12);drawLine(x,y+12,x+10,y);
}

void drawcharY(float x,float y)
{
	drawLine(x+5,y,x+5,y+7);drawLine(x,y+12,x+5,y+7);drawLine(x+10,y+12,x+5,y+7);
}

void drawcharZ(float x,float y)
{
	drawLine(x,y+12,x+10,y+12);drawLine(x+10,y+12,x,y);drawLine(x,y,x+10,y);
}

void drawAxes(matrix3D_t view)
{
#define HALFAXIS  220
#define HALFAXIS1 (HALFAXIS-10)
	point3D_t axes[14]={
		{-HALFAXIS,0,0},{HALFAXIS,0,0},{HALFAXIS1,5,0},{HALFAXIS1,0,0},{0,0,0},
		{0,-HALFAXIS,0},{0,HALFAXIS,0},{0,HALFAXIS1,5},{0,HALFAXIS1,0},{0,0,0},
		{0,0,-HALFAXIS},{0,0,HALFAXIS},{5,0,HALFAXIS1},{0,0,HALFAXIS1}
	};
	vector3D_t vec[14];
	int i;
	for (i=0;i<14;i++) {
		vec[i]=Point2Vector(axes[i]);
		vec[i]=view*vec[i];
	}
	drawPolyline(vec,14);
	drawcharX(vec[1].v[0],vec[1].v[1]);
	drawcharY(vec[6].v[0],vec[6].v[1]);
	drawcharZ(vec[11].v[0]-14,vec[11].v[1]);
}

//////////////////////////////////////////////////////////////////
typedef struct {
	int NumberofVertices; //in the face
	short int pnt[8];
} face_t;
typedef struct {
	int NumberofVertices; //of the object
	point3D_t pnt[MAXSIZE];
	vector3D_t NormalVector[MAXSIZE]; // at the pnt
	int NumberofFaces; //of the object
	face_t fc[MAXSIZE];
} smoothpolyhedron_t;

static void makeSphere(smoothpolyhedron_t &sphere,float r)
{
	// r : radius of the sphere
	float latitude;
	float longitude;
	int NumLatEdge=18;
	int NumLngEdge=32;
	int i,j,k;
	vector3D_t unitz={0,0,1,1};
	vector3D_t unityn={0,1,0,1};
	vector3D_t unitys={0,-1,0,1};
	matrix3D_t mat;
	
	sphere.NumberofVertices=1+(NumLatEdge-1)*NumLngEdge+1;

	sphere.NormalVector[0]=unityn;
	sphere.pnt[0]=Vector2Point(r*sphere.NormalVector[0]);
	for(i=1;i<NumLatEdge;i++) {
		latitude=(NumLatEdge/2.-i)/(float)NumLatEdge*M_PI;
		mat=rotationXMTX(-latitude);
		for(j=0;j<NumLngEdge;j++) {
			k=NumLngEdge*(i-1)+j+1;
			longitude=(float)j/NumLngEdge*2.*M_PI;
			sphere.NormalVector[k]=rotationYMTX(longitude)*mat*unitz;
			sphere.pnt[k]=Vector2Point(r*sphere.NormalVector[k]);
		}
	}
	k=(NumLatEdge-1)*NumLngEdge+1;
	sphere.NormalVector[k]=unitys;
	sphere.pnt[k]=Vector2Point(r*sphere.NormalVector[k]);

	sphere.NumberofFaces=NumLatEdge*NumLngEdge;

	for(i=0;i<NumLatEdge;i++) {
		if (i==0) {
			for(j=0;j<NumLngEdge;j++) {
				k=j;
				sphere.fc[k].NumberofVertices=3;
				sphere.fc[k].pnt[0]=0;
				sphere.fc[k].pnt[1]=k+1;
				if (j!=NumLngEdge-1) {
					sphere.fc[k].pnt[2]=k+2;
				} else {
					sphere.fc[k].pnt[2]=1;
				}
			}
		} else if (i<NumLatEdge-1) {
			for(j=0;j<NumLngEdge;j++) {
				k=NumLngEdge*i+j;
				sphere.fc[k].NumberofVertices=4;
				sphere.fc[k].pnt[0]=k+1-NumLngEdge;
				sphere.fc[k].pnt[1]=k+1;
				if (j!=NumLngEdge-1) {
					sphere.fc[k].pnt[2]=k+2;
					sphere.fc[k].pnt[3]=k+2-NumLngEdge;
				} else {
					sphere.fc[k].pnt[2]=NumLngEdge*i+1;
					sphere.fc[k].pnt[3]=NumLngEdge*i+1-NumLngEdge;
				}
			}
		} else {
			for(j=0;j<NumLngEdge;j++) {
				k=NumLngEdge*i+j;
				sphere.fc[k].NumberofVertices=3;
				sphere.fc[k].pnt[0]=k+1-NumLngEdge;
				sphere.fc[k].pnt[1]=(NumLatEdge-1)*NumLngEdge+1;
				if (j!=NumLngEdge-1) {
					sphere.fc[k].pnt[2]=k+2-NumLngEdge;
				} else {
					sphere.fc[k].pnt[2]=NumLngEdge*i+1-NumLngEdge;
				}
			}
		}
	}
}

static void makeTorus(smoothpolyhedron_t &torus,float r0,float r1)
{
	// r1 : radius of the ring
	// r0 : radius of the circle
	float circleangle;
	float ringangle;
	int NumCclEdge=20;
	int NumRngEdge=40;
	int i,j,k;
	vector3D_t unitx={1,0,0,1};
	vector3D_t vec;
	matrix3D_t mat;
	
	torus.NumberofVertices=NumCclEdge*NumRngEdge;

	mat=translationMTX(r1,0,0)*scalingMTX(r0,r0,r0);
	for(j=0;j<NumCclEdge;j++) {
		circleangle=j/(float)NumCclEdge*2.*M_PI;
		torus.NormalVector[j]=rotationZMTX(circleangle)*unitx;
		torus.pnt[j]=Vector2Point(mat*torus.NormalVector[j]);
	}
	for(i=1;i<NumRngEdge;i++) {
		ringangle=i/(float)NumRngEdge*2.*M_PI;
		mat=rotationYMTX(ringangle);
		for(j=0;j<NumCclEdge;j++) {
			k=NumCclEdge*i+j;
			torus.NormalVector[k]=mat*torus.NormalVector[j];
			vec=Point2Vector(torus.pnt[j]);
			torus.pnt[k]=Vector2Point(mat*vec);
		}
	}

	torus.NumberofFaces=NumCclEdge*NumRngEdge;

	for(i=0;i<NumRngEdge;i++) {
		if (i<NumRngEdge-1) {
			for(j=0;j<NumCclEdge;j++) {
				k=NumCclEdge*i+j;
				torus.fc[k].NumberofVertices=4;
				torus.fc[k].pnt[0]=k;
				torus.fc[k].pnt[1]=k+NumCclEdge;
				if (j!=NumCclEdge-1) {
					torus.fc[k].pnt[2]=k+NumCclEdge+1;
					torus.fc[k].pnt[3]=k+1;
				} else {
					torus.fc[k].pnt[2]=NumCclEdge*i+NumCclEdge;
					torus.fc[k].pnt[3]=NumCclEdge*i;
				}
			}
		} else {
			for(j=0;j<NumCclEdge;j++) {
				k=NumCclEdge*i+j;
				torus.fc[k].NumberofVertices=4;
				torus.fc[k].pnt[0]=k;
				torus.fc[k].pnt[1]=j;
				if (j!=NumCclEdge-1) {
					torus.fc[k].pnt[2]=j+1;
					torus.fc[k].pnt[3]=k+1;
				} else {
					torus.fc[k].pnt[2]=0;
					torus.fc[k].pnt[3]=NumCclEdge*i;
				}
			}
		}
	}
}

void userdraw(void)
{
	static int tick=0;
	float theta=0.5;
	matrix3D_t tilting=rotationXMTX(theta)*rotationYMTX(-theta);

	int disp=(tick/200)%2;
	static float zbuffer[640][480];
	static smoothpolyhedron_t sphere0; // under memory constraint
	static smoothpolyhedron_t sphere;  // under memory constraint
	static smoothpolyhedron_t torus0;  // under memory constraint
	static smoothpolyhedron_t torus;   // under memory constraint
	vector3D_t unitz={0,0,1,1};
	vector3D_t LightVector0=rotationYMTX(0.2)*rotationXMTX(-1.2)*unitz;
	vector3D_t LightVector=tilting*LightVector0;
	vector3D_t ViewVector={0,0,1,1};
	vector3D_t ZeroVector={0,0,0,1};
	color_t White={1,1,1};
	color_t Cyan={0,1,1};
	color_t Red={1,0,0};
	color_t Green={0,1,0};
	vector3D_t vec[MAXSIZE];
	vector3D_t nrmvec[MAXSIZE];
	vector3D_t vecbuff[8];
	vector3D_t nrmvecbuff[8];
	vector3D_t NormalVector;
	point3D_t buff[8];
	color_t colbuff[8];
	float normalzi;//z of normal vector of the face
	matrix3D_t rot,rots,rots0,mat;
	color_t fillcolor;
	int i,j;

	if (tick==0) {
		makeSphere(sphere0,80);
		makeTorus(torus0,60,180);
	}
	setColor(White);
	drawAxes(tilting);
	sphere=sphere0;
	torus=torus0;
	for (i=0;i<640;i++) for (j=0;j<480;j++) {
		zbuffer[i][j]=-10000;
	}
	switch(disp) {
	case 0:  // rotation about z-axis
		// removing hidden faces and Phong model Flat shading
		// Z buffer
		glutSetWindowTitle("torus&sphere 2 - Flat shading with Z buffer");
		rots=rotationZMTX(0.04*tick)*translationMTX(180,0,0);
		mat=tilting*rots;
		for (i=0;i<sphere.NumberofVertices;i++) {
			vec[i]=Point2Vector(sphere.pnt[i]);
			vec[i]=mat*vec[i];
		}
		for (i=0;i<sphere.NumberofFaces;i++) {
			for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
				vecbuff[j]=vec[sphere.fc[i].pnt[j]];
			}
			NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
			normalzi=NormalVector.v[2];
			if (0.<normalzi) {
				for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
					buff[j]=Vector2Point(vecbuff[j]);
				}
				NormalVector=unitVector(NormalVector);
				fillcolor=PhongModel(LightVector,NormalVector,ViewVector,Green);
				fillPolygonZBuff(buff,sphere.fc[i].NumberofVertices,fillcolor,zbuffer);
			}
		}

		rot=rotationZMTX(0.04*tick)*rotationYMTX(0.02*tick);
		mat=tilting*rot;
		for (i=0;i<torus.NumberofVertices;i++) {
			vec[i]=Point2Vector(torus.pnt[i]);
			vec[i]=mat*vec[i];
		}
		for (i=0;i<torus.NumberofFaces;i++) {
			for (j=0;j<torus.fc[i].NumberofVertices;j++) {
				vecbuff[j]=vec[torus.fc[i].pnt[j]];
			}
			NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
			normalzi=NormalVector.v[2];
			if (0.<normalzi) {
				for (j=0;j<torus.fc[i].NumberofVertices;j++) {
					buff[j]=Vector2Point(vecbuff[j]);
				}
				NormalVector=unitVector(NormalVector);
				fillcolor=PhongModel(LightVector,NormalVector,ViewVector,Cyan);
				fillPolygonZBuff(buff,torus.fc[i].NumberofVertices,fillcolor,zbuffer);
			}
		}

		break;
	case 1: // rotation about z-axis
		//removing hidden faces and Phong model Gouraud shading
		// Z buffer
		glutSetWindowTitle("torus&sphere 2 - Gouraud shading with Z buffer");
		rots0=rotationZMTX(0.04*tick);
		rots=rots0*translationMTX(180,0,0);
		mat=tilting*rots;
		for (i=0;i<sphere.NumberofVertices;i++) {
			vec[i]=Point2Vector(sphere.pnt[i]);
			vec[i]=mat*vec[i];
		}
		mat=tilting*rots0;
		for (i=0;i<sphere.NumberofVertices;i++) {
			nrmvec[i]=mat*sphere.NormalVector[i];
		}
		for (i=0;i<sphere.NumberofFaces;i++) {
			for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
				vecbuff[j]=vec[sphere.fc[i].pnt[j]];
				nrmvecbuff[j]=nrmvec[sphere.fc[i].pnt[j]];
			}
			NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
			normalzi=NormalVector.v[2];
			if (0.<normalzi) {
				for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
					buff[j]=Vector2Point(vecbuff[j]);
					NormalVector=unitVector(nrmvecbuff[j]);
					colbuff[j]=PhongModel(LightVector,NormalVector,ViewVector,Green);
				}
				gradatePolygonZBuff(buff,colbuff,sphere.fc[i].NumberofVertices,zbuffer);
			}
		}

		rot=rotationZMTX(0.04*tick)*rotationYMTX(0.02*tick);
		mat=tilting*rot;
		for (i=0;i<torus.NumberofVertices;i++) {
			vec[i]=Point2Vector(torus.pnt[i]);
			vec[i]=mat*vec[i];
		}
		for (i=0;i<torus.NumberofVertices;i++) {
			nrmvec[i]=mat*torus.NormalVector[i];
		}
		for (i=0;i<torus.NumberofFaces;i++) {
			for (j=0;j<torus.fc[i].NumberofVertices;j++) {
				vecbuff[j]=vec[torus.fc[i].pnt[j]];
				nrmvecbuff[j]=nrmvec[torus.fc[i].pnt[j]];
			}
			NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
			normalzi=NormalVector.v[2];
			if (0.<normalzi) {
				for (j=0;j<torus.fc[i].NumberofVertices;j++) {
					buff[j]=Vector2Point(vecbuff[j]);
					NormalVector=unitVector(nrmvecbuff[j]);
					colbuff[j]=PhongModel(LightVector,NormalVector,ViewVector,Cyan);
				}
				gradatePolygonZBuff(buff,colbuff,torus.fc[i].NumberofVertices,zbuffer);
			}
		}
		break;
	default:
		break;
	}
	tick+=2;
}

int main(int argc, char **argv)
{
	glutInit(&argc,argv);
	glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB );
	glutInitWindowPosition(100,100);
	glutInitWindowSize(640,480);
	glutCreateWindow ("torus&sphere 2");
	glClearColor(0.0, 0.0, 0.0, 0.0);
	gluOrtho2D(-320., 320., -240.0, 240.0);
	  // Define the dimensions of the Orthographic Viewing Volume
	glutIdleFunc(display); // idle event call back
	glutDisplayFunc(display);
	glutMainLoop();
	return 0;
}