// (c) Dinko Korunic, 36355514, kreator@fly.srk.fer.hr
// Zadatak broj 8-1 iz predmeta Racunalna grafika

#include <iostream.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <unistd.h>

#define MAXX 640 // max x
#define MAXY 480 // max y
#define LPOB 8  // modifikator
#define DINT 60 // zbraja intenzitetu
#define MINT 1.5 // mnozi intenzitet
#define MYSTEP 0.01 // stepping
#define MYSLEEP 1 // sleeping time

class MyDisplay
{
	// klasa MyDisplay u kojoj se nalaze inicijalizacijske xlib
	// rutine, kao i postavljanje background i foreground boje, itd.
	XGCValues gcv;
	unsigned long wp, bp;
	int winx, winy;
	public:
		Display *disp;
		Window win;
		GC gc;
		XEvent ev;
		void MyWait(void);
		int winsx, winsy, screen;
		MyDisplay(int _winx, int _winy, int _winsx,
				int _winsy);
		~MyDisplay();
};

MyDisplay::MyDisplay(int _winx=0, int _winy=0, 
	int _winsx=MAXX, int _winsy=MAXY) :
	winx(_winx), winy(_winy), winsx(_winsx), winsy(_winsy)
{

	// konstruktor koji sluzi za misc. inicijalizaciju
	cout << "Initialising graphic subsystem.." << endl;
	// otvaranje displaya
	if ((disp=XOpenDisplay(NULL))==NULL)
	{
		cerr << "I can't open display." << endl;
		exit(EXIT_FAILURE);
	}
	screen=DefaultScreen(disp);
	// stvaranje prototipnog prozora
	win=XCreateSimpleWindow(disp, DefaultRootWindow(disp),
		winx, winy, winsx, winsy, 1, wp=WhitePixel(disp, screen),
		bp=BlackPixel(disp, screen));
	XSelectInput(disp, win, StructureNotifyMask | KeyPressMask
		| ExposureMask);
	// mapiranje prozora
	XMapWindow(disp, win);
	while(1)
	{
		// cekaj dok nije gotovo
		XNextEvent(disp, &ev);
		if (ev.type==MapNotify) break;
	}
	gcv.foreground=wp;
	gcv.background=bp;
	// stvori gc
	gc=XCreateGC(disp, win, GCForeground | GCBackground, &gcv);
	cout << "done." << endl;
}

MyDisplay::~MyDisplay()
{
	// destruktor za graficki engine
	cout << "Shutting graphic subsystem.." << endl;
	XFreeGC(disp, gc);
	XDestroyWindow(disp, win);
	XCloseDisplay(disp);
	cout << "done." << endl;
}

void MyDisplay::MyWait(void)
{
	// postavi wait na keypress
	XSelectInput(disp, win, KeyPressMask | ExposureMask);
	while(1)
	{
		XNextEvent(disp, &ev);
		if (ev.type==KeyPress) break;
	}
}

// vrh poligona
struct Vrh
{
	int x, y, z; // koordinate u sustavu scene
	double xo, yo, zo; // koordinate u sustavu oka
	int xp, yp, // koordinate prikaza
		intenzitet; // intenzitet u vrhu
	double vx, vy, vz; // komponente vektora koji izvire iz vrha
};

// struktura u koju se ucitavaju vrhovi tijela
struct Matrica
{
	int t, // broj vrhova po katu
		k, // broj katova
		boja;
	Vrh **Mat; // matrica od k redaka i t stupaca
};

// poligon
struct Poligon
{
	int n, // broj vrhova poligona
		boja, // boja 0-crvena 1-zelena 2-plava 3-siva
		vidljivost;
	float A, B, C, D; // koeficijenti ranvine u kojoj lezi poligon
	Vrh **Polje; // polje vrhova poligona orijentirano u smjeru
			// kazaljke na satu
};

class MiscDraw : public MyDisplay
{
	Colormap cmap;
	XColor xcolor, colorcell;
	int darkcolor, lightcolor, black, white;
	public:
		XImage *image;
		long translate[4]; /* for converting colors */
		MiscDraw();
};

MiscDraw::MiscDraw()
{
	cmap=DefaultColormap(disp, screen);
	if (XAllocNamedColor(disp, cmap, "red", &colorcell, &xcolor))
		translate[0]=colorcell.pixel;
	if (XAllocNamedColor(disp, cmap, "green", &colorcell, &xcolor))
		translate[1]=colorcell.pixel;
	if (XAllocNamedColor(disp, cmap, "blue", &colorcell, &xcolor))
		translate[2]=colorcell.pixel;
	if (XAllocNamedColor(disp, cmap, "grey", &colorcell, &xcolor))
		translate[3]=colorcell.pixel;
	image=XGetImage(disp, win, 0, 0, MAXX, MAXY, AllPlanes, ZPixmap);
}

class MyDraw8 : public MiscDraw
{
	Matrica MyMatrica; // za smjestaj vrhova
	Poligon *PoljePoligona; // polje ciji elementi su strukture koje
				// sadrzavaju poligone
	int BrojPoligona, // sadrzi broj poligona od kojih je
				// sastavljeno tijelo
		rx[4], ry[4], rz[4];
	Vrh Ociste, Glediste, Izvor;
	void Input(Matrica *);
	void DajIntenzitet(Vrh *);
	void OdrediVidljivost(Poligon *);
	void PridodajVrh(Poligon *);
	void IzracunajRavninu(Poligon *);
	void Topologija(Matrica *, Poligon *);
	void TransformirajPogled(Vrh *);
	void Projekcija(Vrh *);
	void PridodajVrhovima(Poligon *);
	double B(int, double);
	int Bezier(int *, double);
	public:
		MyDraw8();
};

MyDraw8::MyDraw8()
{
	Input(&MyMatrica);
	PoljePoligona=new Poligon[BrojPoligona=2+MyMatrica.t*(MyMatrica.k-1)];
	// popunjavamo polje poligona sa svim potrebnim poligonima
	Topologija(&MyMatrica, PoljePoligona);
	for (double bz=0; bz<=1; bz+=MYSTEP)
	{
		Ociste.x=Bezier(rx,bz);
		Ociste.y=Bezier(ry,bz);
		Ociste.z=Bezier(rz,bz);
		
		int i, j;
		// idemo po svim vrhovima i radimo transformacije
		for (i=0; i<MyMatrica.k; ++i) // po katovima tijela
			for (j=0; j<MyMatrica.t; ++j) // po vrhovima jednog kata
			{
				TransformirajPogled(&MyMatrica.Mat[i][j]);
				Projekcija(&MyMatrica.Mat[i][j]);
			}
		// idemo po svim poligonima, odredujemo da li su vidljivi
		// ili ne i usput sumiramo vrijednosti vektora na
		// poligone, te tu vrijednost upisujemo u vektore
		// definirane u strukturi Vrh
		for (i=0; i<BrojPoligona; ++i)
		{
			IzracunajRavninu(&PoljePoligona[i]);
			OdrediVidljivost(&PoljePoligona[i]);
			PridodajVrhovima(&PoljePoligona[i]);
		}
		// idemo po svim vrhovima i reduciramo vrijednost
		// pojedinih vektora dijeleci ih sa 3 (jer je svaki vrh
		// sjeciste tri poligona), a minus stoji zato jer su
		// vektori bili okrenuti prema unutra, te uz pomoc tako
		// dobivene vrijednosti racunamo intenzitet; istovremeno
		// koordinate vrha u sustavu prikaza prevodimo u ekranske
		// koordinate (uz pomoc ishodista u sredinu ekrana)
		for (i=0; i<MyMatrica.k; ++i) // ide se po katovima
			for (j=0; j<MyMatrica.t; ++j) // ide se po vrhovima
							// pojedinog kata
			{
				MyMatrica.Mat[i][j].vx/=-3;
				MyMatrica.Mat[i][j].vy/=-3;
				MyMatrica.Mat[i][j].vz/=-3;
				MyMatrica.Mat[i][j].xp+=MAXX/2;
				MyMatrica.Mat[i][j].yp+=MAXY/2;
				DajIntenzitet(&MyMatrica.Mat[i][j]);
			}
		// crtamo hidden line wireframe
		for (i=0; i<BrojPoligona; ++i)
			if (PoljePoligona[i].vidljivost==1)
			for (j=0; j<PoljePoligona[i].n; ++j)
				XDrawLine(disp, win, gc,
				PoljePoligona[i].Polje[j]->xp,
				PoljePoligona[i].Polje[j]->yp,
			PoljePoligona[i].Polje[(j+1)%PoljePoligona[i].n]->xp,
			PoljePoligona[i].Polje[(j+1)%PoljePoligona[i].n]->yp);
		XFlush(disp);
		usleep(MYSLEEP);
		XClearWindow(disp, win);
	}
	MyWait();
}

void MyDraw8::Input(Matrica *M)
{
	cout << "Unesi broj katova i broj vrhova po katu"
		" i boju tijela" << endl;
	cin >> M->k;
	cin >> M->t;
	cin >> M->boja;
	M->Mat=new (Vrh *)[M->k];
	int i;
	for (i=0; i<M->k; ++i)
		M->Mat[i]=new Vrh[M->t];

	int j;
	for (i=0; i<M->k; ++i)
		for (j=0; j<M->t; ++j)
		{
			cin >> M->Mat[i][j].x;
			cin >> M->Mat[i][j].y;
			cin >> M->Mat[i][j].z;
			M->Mat[i][j].vx=M->Mat[i][j].vy=M->Mat[i][j].vz=0;
		}
	cout << "Unesi koordinate ocista (x, y, z):" << endl;
	cin >> Ociste.x;
	cin >> Ociste.y;
	cin >> Ociste.z;
	cout << "Unesi koordinate gledista (x, y, z):" << endl;
	cin >> Glediste.x;
	cin >> Glediste.y;
	cin >> Glediste.z;
	cout << "Unesi rx, ry i rz" << endl;
	for (i=0; i<4; ++i)
	{
		cin >> rx[i];
		cin >> ry[i];
		cin >> rz[i];
	}
}

void MyDraw8::DajIntenzitet(Vrh *V)
{
	// racunamo vektor iz vrha prema izvoru
	double ax=Ociste.x-V->x,
		ay=Ociste.y-V->y,
		az=Ociste.z-V->z;

	// racunamo kut koji zatvaraju taj vektor i vektor iz vrha nastao
	// kao prosjecni vektor normala ploha koje se sjeku u tom vrhu
	double coskut=(V->vx*ax+V->vy*ay+V->vz*az)/
			sqrt(ax*ax+ay*ay+az*az)/
		sqrt(V->vx*V->vx+V->vy*V->vy+V->vz*V->vz);
	if (coskut<0) coskut=-0.25;
	V->intenzitet=10+53*coskut;
	if (V->intenzitet<10) V->intenzitet=10;
}

void MyDraw8::OdrediVidljivost(Poligon *Ulaz)
{
	double xsred=0, ysred=0, zsred=0;
	int i;
	for (i=0; i<Ulaz->n; ++i) // odredjujemo koordinate sredine poligona
	{
		xsred+=Ulaz->Polje[i]->x; // radimo u sustavu scene
		ysred+=Ulaz->Polje[i]->y;
		zsred+=Ulaz->Polje[i]->z;
	}
	xsred/=i; // odredili smo ih (u i=ulaz->n)
	ysred/=i;
	zsred/=i;
	double ax=Ociste.x-xsred, // odredili smo vektor s hvatistem u
		ay=Ociste.y-ysred, // sredini poligona
		az=Ociste.z-zsred; // i vrhom u ocistu

	// kut -> ustvari vrijednost kosinusa
	double kut=acos((ax*Ulaz->A+ay*Ulaz->B+az*Ulaz->C)
		/sqrt(ax*ax+ay*ay+az*az)
		/sqrt((Ulaz->A*Ulaz->A)+(Ulaz->B*Ulaz->B)+(Ulaz->C*Ulaz->C)));

	if (kut<M_PI/2)
		Ulaz->vidljivost=0;
	else
		Ulaz->vidljivost=1;
}

void MyDraw8::PridodajVrhovima(Poligon *P)
{
	// odredjujemo normirane vrijednosti vektora
	double aps=sqrt(P->A*P->A+P->B*P->B+P->C*P->C),
		xnorm=P->A/aps,
		ynorm=P->B/aps,
		znorm=P->C/aps;
	for (int i=0; i<P->n; ++i) // idemo po svim vrhovima poligona
	{
		P->Polje[i]->vx+=xnorm; // i pridodajemo im vrijednosti
		P->Polje[i]->vy+=ynorm; // normiranog vektora
		P->Polje[i]->vz+=znorm;
	}
}

void MyDraw8::IzracunajRavninu(Poligon *P)
{
	P->A=(P->Polje[1]->y - P->Polje[0]->y)
		*(P->Polje[2]->z - P->Polje[0]->z)
		-(P->Polje[1]->z - P->Polje[0]->z)
		*(P->Polje[2]->y - P->Polje[0]->y);
	P->B=-(P->Polje[1]->x - P->Polje[0]->x)
		*(P->Polje[2]->z - P->Polje[0]->z)
		+(P->Polje[1]->z - P->Polje[0]->z)
		*(P->Polje[2]->x - P->Polje[0]->x);
	P->C=(P->Polje[1]->x - P->Polje[0]->x)
		*(P->Polje[2]->y - P->Polje[0]->y)
		-(P->Polje[1]->y - P->Polje[0]->y)
		*(P->Polje[2]->x - P->Polje[0]->x);
	P->D=-(P->Polje[0]->x * P->A)-(P->Polje[0]->y * P->B)
		-(P->Polje[0]->z * P->C);
}

void MyDraw8::Topologija(Matrica *M, Poligon *P)
{
	int n=0;
	// ovo tu stvara prvi poligon - bazu na najgornjem katu
	P[n].Polje=new (Vrh *)[M->t];
	P[n].n=M->t;
	P[n].boja=M->boja;
	int i;
	for (i=0; i<M->t; ++i)
		P[n].Polje[i]=&M->Mat[0][i];

	// stvaranje popisa vrhova za poligone plasta koliko ima katova
	// poligona plasta
	int j;
	for (i=0; i<M->k-1; ++i)
	{
		// poligona po katu ima onoliko koliko je tocaka zadano po
		// istom
		for (j=0; j<M->t; ++j)
		{
			P[++n].n=4;
			P[n].boja=M->boja;
			P[n].Polje=new (Vrh *)[4];
			P[n].Polje[0]=&M->Mat[i][j];
			P[n].Polje[1]=&M->Mat[i+1][j];
			P[n].Polje[2]=&M->Mat[i+1][(j+1)%M->t];
			P[n].Polje[3]=&M->Mat[i][(j+1)%M->t];
		}
	}

	//stvara drugu bazu - donju
	P[++n].Polje=new (Vrh *)[M->t];
	P[n].n=M->t;
	P[n].boja=M->boja;
	for (i=0; i<M->t; ++i)
		P[n].Polje[i]=&M->Mat[M->k-1][M->t-1-i];
}

void MyDraw8::TransformirajPogled(Vrh *V)
{
	double xg1=Glediste.x-Ociste.x,
		yg1=Glediste.y-Ociste.y,
		zg1=Glediste.z-Ociste.z,
		xg2=sqrt(xg1*xg1+yg1*yg1),
		sina=yg1/xg2,
		cosa=xg1/xg2,
		sinb=xg2/sqrt(xg1*xg1+yg1*yg1+zg1*zg1),
		cosb=zg1/sqrt(xg1*xg1+yg1*yg1+zg1*zg1);
	V->xo=V->x*sina-V->y*cosa-Ociste.x*sina+Ociste.y*cosa;
	V->yo=-V->x*cosa*cosb-V->y*sina*cosb+V->z*sinb+Ociste.x*cosa*cosb
		+Ociste.y*sina*cosb-Ociste.z*sinb;
	V->zo=V->x*cosa*sinb+V->y*sina*sinb+V->z*cosb-
		Ociste.x*cosa*sinb-Ociste.y*sina*sinb-Ociste.z*cosb;

	Glediste.xo=Glediste.yo=0;
	Glediste.zo=sqrt(xg1*xg1+yg1*yg1+zg1*zg1);
}

void MyDraw8::Projekcija(Vrh *V)
{
	V->xp=V->xo/V->zo*Glediste.zo;
	V->yp=V->yo/V->zo*Glediste.zo;
}

double MyDraw8::B(int i, double t)
{
	switch(i)
	{
		case 0: return (1.-t)*(1.-t)*(1.-t);
		case 1: return 3.*t*(1.-t)*(1.-t);
		case 2: return 3.*t*t*(1.-t);
		case 3: return t*t*t;
		default: return 0.;
	}
}

int MyDraw8::Bezier(int *r, double t)
{
	int i;
	double p=0.;
	for (i=0; i<4; ++i)
		p+=r[i]*B(i,t);
	return p;
}

int main(void)
{
	MyDraw8 MyOb;
	return EXIT_SUCCESS;
}