class poligon implements axon
{
	private var puncte:Array;
	private var clip:MovieClip;
	private var i,j,k,xuper = 0, yuper = 0, zuper = 1, zBoost = 0;
	private var motherCube:cub;
	public var style, defStyle:stil;
	private var vis:Boolean;
	public var camDist, camDist1, camDist2:Number;
	public var faceN:Number;
		
	public function poligon(mama:cub,freza:stil)
	{
		puncte = new Array();
		clip = new MovieClip();
		style = new stil();
		motherCube = mama;		
		style = freza ? freza : style;
		vis = true;	
		defStyle = motherCube.style;
		faceN = 0;
		
	}
	
	public function adaugaPunct(a:point) // adauga puncte la array.
	{
		puncte.push(a);
	}
	
	public function set mc(a:MovieClip) 
	{
		clip = a;
		clip.motherC = motherCube; //link up to the cube of creation. 
	}
	public function iBlur(a:stil) 
	{
		style = a;
	}
	
	public function oBlur() 
	{
		style = defStyle;
	}
		
	public function rotate(q:quaternion) {
		
		for(i=0;i<puncte.length;i++) 
		{
			puncte[i].rotate(q);
		}
	}
	
	private function backface(a,b,c,d) 
	{
		//a,b si c sunt primele trei puncte, cele cu care definim planul in care se afla poligonul.
		//trebuie sa aflam normala planului. definesc doi vectori, si apoi cross product intre ei :) simplu.
		//mai nou face si cameraDistance adica ZSorting ;) utilizand 2 puncte simetrice. 
		var m,n,N,V,V2:point;
		m = new point(); n = new point(); N = new point(); V = new point(); V2 = new point();
		var cam = _root.scene1.cam.c;
		m.x = a.x - b.x; 
		m.y = a.y - b.y; 
		m.z = a.z - b.z; 		
		n.x = c.x - b.x; 
		n.y = c.y - b.y; 
		n.z = c.z - b.z;
		//( A.x , A.y , A.z ) X ( B.x , B.y , B.z ) = ( A.y * B.z - A.z * B.y , A.z * B.x - A.x * B.z , A.x * B.y - A.y * B.x)
		N.x = m.y * n.z - m.z * n.y; 
		N.y = m.z * n.x - m.x * n.z;
		N.z = m.x * n.y - m.y * n.x;
		var magN = Math.sqrt(N.x * N.x + N.y * N.y + N.z * N.z);
		N.x /= magN; N.y /= magN; N.z /= magN;
		//view vector. adica vectorul din camera pana-n panza poligonului.
		V.x = cam.x - b.x; V.y = cam.y - b.y; V.z = cam.z - b.z;
		var magV = Math.sqrt(V.x*V.x + V.y*V.y + V.z*V.z);
		V.x /= magV; V.y /= magV; V.z /= magV;
		//acum ar trebui sa mananc un dot product intre N si V. sau V si N. unde N = normala poligonului.
		var theta = (V.x * N.x + V.y * N.y + V.z * N.z)/(magV * magN);
		V2.x = cam.x - d.x; 
		V2.y = cam.y - d.y; 
		V2.z = cam.z - d.z;
		var magV2 = Math.sqrt(V2.x*V2.x + V2.y*V2.y + V2.z*V2.z);
		camDist2 = magV2;
		camDist1 = magV; 
		camDist = (camDist1 + camDist2)/2;
		return (theta < 0);
		//
	}

	public function deseneaza():Void
	{
		vis = backface(puncte[0],puncte[1],puncte[2],puncte[3]); 
		if(!_root.bfc) { vis = true; }
		
		if(vis) 
		{
		for(i=0;i<puncte.length;i++) 
		{
			puncte[i].worldToCamera(_root.scene1.cam); //transformarea coordonatelor din WORLD SPACE in CAMERA SPACE
			puncte[i].pPoint(); //transformarea in IMAGE SPACE (ecran).
		}
				
			clip.clear();
			clip.moveTo(puncte[0]._xp,puncte[0]._yp);
			clip.lineStyle(style._lGrosime, style._lCuloare, style._lTransp);
			clip.beginFill(style._fCuloare, style._fTransp);
			i = 1;
			while(i < puncte.length) 
			{
				clip.lineTo(puncte[i]._xp,puncte[i]._yp);
				i++;
			}
			clip.lineTo(puncte[0]._xp,puncte[0]._yp);
			clip.endFill();
			
			clip.swapDepths(1000000 - camDist*1000);
				
			clip.onRollOver = clip.onDragOver = function (motherCube) 
			{
				if(this.motherC.superCub) {
				this.motherC.blurAll(_root.omo);
				}
			}
			clip.onDragOut = clip.onRollOut = function ()
			{
				if(this.motherC.superCub) {
				this.motherC.deBlurAll();
				}
			}
			clip.onPress = function () 
			{
				if((this.motherC.superCub)&&(!_root.anyRot)) {
					if(Key.isDown(Key.SHIFT)) { trace("Uber invert."); _root.r.FRotate(this.motherC.superCub,-1); } else {
					_root.r.FRotate(this.motherC.superCub,1); }
				}
			}
		} else {
			//daca vis = 0 (poligonul respectiv este invizibil) sa nu ramana pe ecran urma sa. 
			clip.clear();
		}
	}
	
} //sfarsit