#include "RendererConfig.h"
#ifndef USE_SOFTWARE_TNL

#include "3d.h"
#include "HardwareInternal.h"
#include "renderer.h"

#define round(v) ( (int)( ((v) + 0.5f) ) )

//draws a line. takes two points.  returns true if drew
void g3_DrawLine(ddgr_color color,g3Point *p0,g3Point *p1)
{
	ubyte codes_or;
	bool was_clipped=0;

	if (p0->p3_codes & p1->p3_codes)
		return;

	codes_or = p0->p3_codes | p1->p3_codes;

	if (codes_or)
	{
		ClipLine(&p0,&p1,codes_or);
		was_clipped = 1;
	}

	if (!(p0->p3_flags & PF_PROJECTED))
	{
		g3_ProjectPoint(p0);
	}

	if (!(p1->p3_flags & PF_PROJECTED))
	{
		g3_ProjectPoint(p1);
	}

	rend_SetFlatColor (color);
	rend_DrawLine( round(p0->p3_sx),round(p0->p3_sy),round(p1->p3_sx),round(p1->p3_sy));

	//If was clipped, free temp points
	if (was_clipped)
	{
		if (p0->p3_flags & PF_TEMP_POINT)
		{
			FreeTempPoint(p0);
		}

		if (p1->p3_flags & PF_TEMP_POINT)
		{
			FreeTempPoint(p1);
		}

		//Make sure all temp points have been freed
		CheckTempPoints();
	}
}

//draws a line based on the current setting of render states. takes two points.  returns true if drew
void g3_DrawSpecialLine(g3Point *p0,g3Point *p1)
{
	ubyte codes_or;
	bool was_clipped=0;

	if (p0->p3_codes & p1->p3_codes)
		return;

	codes_or = p0->p3_codes | p1->p3_codes;

	if (codes_or)
	{

		ClipLine(&p0,&p1,codes_or);

		was_clipped = 1;
	}

	if (!(p0->p3_flags & PF_PROJECTED))
		g3_ProjectPoint(p0);

	if (!(p1->p3_flags & PF_PROJECTED))
		g3_ProjectPoint(p1);

	rend_DrawSpecialLine (p0,p1);

	//If was clipped, free temp points
	if (was_clipped)
	{
		if (p0->p3_flags & PF_TEMP_POINT)
			FreeTempPoint(p0);

		if (p1->p3_flags & PF_TEMP_POINT)
			FreeTempPoint(p1);

		//Make sure all temp points have been freed
		CheckTempPoints();
	}
}

//returns true if a plane is facing the viewer. takes the unrotated surface 
//normal of the plane, and a point on it.  The normal need not be normalized
bool g3_CheckNormalFacing(vector *v,vector *norm)
{
	vector tempv;

	tempv = View_position - *v;

	return ((tempv * *norm) > 0);
}

bool DoFacingCheck(vector *norm,g3Point **vertlist,vector *p)
{
	if (norm)
	{
		//have normal
		ASSERT(norm->x || norm->y || norm->z);
		return g3_CheckNormalFacing(p,norm);
	}
	else
	{
		//normal not specified, so must compute
		vector tempv;
		//get three points (rotated) and compute normal
		vm_GetPerp(&tempv,&vertlist[0]->p3_vec,&vertlist[1]->p3_vec,&vertlist[2]->p3_vec);
		return ((tempv * vertlist[1]->p3_vec) < 0);
	}
}

//like g3_DrawPoly(), but checks to see if facing.  If surface normal is
//NULL, this routine must compute it, which will be slow.  It is better to 
//pre-compute the normal, and pass it to this function.  When the normal
//is passed, this function works like g3_CheckNormalFacing() plus
//g3_DrawPoly().
void g3_CheckAndDrawPoly(int nv,g3Point **pointlist,int bm,vector *norm,vector *pnt)
{
	if (DoFacingCheck(norm,pointlist,pnt))
		g3_DrawPoly(nv,pointlist,bm);
}

int Triangulate_test = 0;

//draw a polygon
//Parameters:	nv - the number of verts in the poly
//					pointlist - a pointer to a list of pointers to points
//					bm - the bitmap handle if texturing.  ignored if flat shading
// Returns 0 if clipped away
int g3_DrawPoly(int nv,g3Point **pointlist,int bm,int map_type,g3Codes *clip_codes)
{
	rend_DrawPolygon3D( bm, pointlist, nv, map_type );
	return 1;

	/*
	int i;
	g3Codes cc;
	bool was_clipped=0;

	if( Triangulate_test && (nv > 3) )
	{
		g3Point *tripoints[3];
		int sum=0;

		for (i=0;i<nv-2;i++) 
		{
			tripoints[0] = pointlist[0];
			tripoints[1] = pointlist[i+1];
			tripoints[2] = pointlist[i+2];
			sum += g3_DrawPoly( 3, tripoints, bm, map_type );
		}

		return sum;
	}

	//Initialize or just used the ones passed in
	if( clip_codes )
	{
		cc = *clip_codes;
	}
	else
	{
		cc.cc_or  = 0;
		cc.cc_and = 0xff;

		//Get codes for this polygon, and copy uvls into points
		for( i = 0; i < nv; ++i ) 
		{
			ubyte c = pointlist[i]->p3_codes;
			cc.cc_and &= c;
			cc.cc_or  |= c;
		}
	}

	//All points off screen?
	if( cc.cc_and )
		return 0;

	//One or more point off screen, so clip
	if( cc.cc_or )
	{
		//Clip the polygon, getting pointer to new buffer
		pointlist = g3_ClipPolygon( pointlist, &nv, &cc );

		//Flag as clipped so temp points will be freed
		was_clipped = 1;

		//Check for polygon clipped away, or clip otherwise failed
		if( (nv==0) || (cc.cc_or&CC_BEHIND) || cc.cc_and )
			goto free_points;
	}

	//Make list of 2d coords (& check for overflow)
	for( i = 0; i < nv; ++i )
	{
		g3Point *p = pointlist[i];

		//Project if needed
		if( !(p->p3_flags&PF_PROJECTED) )
		{
			g3_ProjectPoint(p);
		}
	}

	//Draw!
	rend_DrawPolygon3D( bm, pointlist, nv, map_type );

free_points:;

	//If was clipped, free temp points
	if( was_clipped )
	{
		g3_FreeTempPoints( pointlist, nv );
	}

	return 1;
	*/
}

//draw a sortof sphere - i.e., the 2d radius is proportional to the 3d
//radius, but not to the distance from the eye
void g3_DrawSphere(ddgr_color color,g3Point *pnt,float rad)
{
	if (! (pnt->p3_codes & CC_BEHIND))
	{
		if (! (pnt->p3_flags & PF_PROJECTED))
			g3_ProjectPoint(pnt);

		rend_FillCircle(color, pnt->p3_sx, pnt->p3_sy,(rad * Matrix_scale.x * Window_w2 / pnt->p3_z));
	}
}

//draws a bitmap with the specified 3d width & height 
// If offsets  are not -1, then the blitter draws not from the upper left hand 
// corner of the bitmap, but from size*offsetx,size*offsety
// See Jason for explaination
void g3_DrawBitmap(vector *pos,float width,float height,int bm,int color)
{
	// get the view orientation
	matrix viewOrient;
	g3_GetUnscaledMatrix( &viewOrient );

	// break down the color into components
	float r, g, b;
	if( color != -1 )
	{
		float scale = 1.0f / 255.0f;
		r = GR_COLOR_RED(color)   * scale;
		g = GR_COLOR_GREEN(color) * scale;
		b = GR_COLOR_BLUE(color)  * scale;
	}

	// calculate the four corners
	g3Point corners[4], *pts[4];
	int i;
	for( i = 0; i < 4; ++i )
	{
		pts[i] = &corners[i];

		// calculate the offset for this corner
		float cornerScaleU = ((i&1) ^ ((i&2)>>1)) ? 1.0f : -1.0f;
		float cornerScaleV = (i&2) ? 1.0f : -1.0f;

		// find the point (parallel to the view frame)
		vector cornerPos = *pos + (viewOrient.uvec * (height * -cornerScaleV)) + (viewOrient.rvec * (width * cornerScaleU));
		corners[i].p3_codes = 0;
		g3_RotatePoint( pts[i], &cornerPos );

		// setup the flags, UVs and colors
		corners[i].p3_flags |= PF_UV;
		corners[i].p3_uvl.u = (cornerScaleU * 0.5f) + 0.5f;
		corners[i].p3_uvl.v = (cornerScaleV * 0.5f) + 0.5f;
		if( color == -1 )
		{
			corners[i].p3_flags |= PF_L;
			corners[i].p3_uvl.l = 1.0f;
		}
		else
		{
			corners[i].p3_flags |= PF_RGBA;
			corners[i].p3_uvl.r = r;
			corners[i].p3_uvl.g = g;
			corners[i].p3_uvl.b = b;
		}
		corners[i].p3_uvl.a = 1.0f;
	}

	rend_SetTextureType( TT_LINEAR );
	rend_DrawPolygon3D( bm, pts, 4 );
}

// Draws a bitmap that has been rotated about its center.  Angle of rotation is passed as 'rot_angle'
void g3_DrawRotatedBitmap(vector *pos,angle rot_angle,float width,float height,int bm,int color)
{
	// get the view orientation
	matrix viewOrient;
	g3_GetUnscaledMatrix( &viewOrient );

	matrix rot_matrix;
	vm_AnglesToMatrix( &rot_matrix, 0, 0, rot_angle );

	float w = width;
	float h = height;

	vector rot_vectors[4];
	rot_vectors[0].x = -w; 
	rot_vectors[0].y = h;

	rot_vectors[1].x = w; 
	rot_vectors[1].y = h;

	rot_vectors[2].x = w; 
	rot_vectors[2].y = -h;

	rot_vectors[3].x = -w; 
	rot_vectors[3].y = -h;

	g3Point rot_points[8], *pntlist[8];
	int i;
	for( i = 0; i < 4; ++i )
	{
		vector offset;
		rot_vectors[i].z = 0.0f;
		vm_MatrixMulVector( &offset, &rot_vectors[i], &rot_matrix );

		vector cornerPos = *pos + (viewOrient.uvec * offset.y) + (viewOrient.rvec * offset.x);
		rot_points[i].p3_codes = 0;
		g3_RotatePoint( &rot_points[i], &cornerPos );

		rot_points[i].p3_flags |= PF_UV|PF_RGBA;
		rot_points[i].p3_l     = 1.0f;
		rot_points[i].p3_uvl.u = ((i&1) ^ ((i&2)>>1)) ? 1.0f : 0.0f;
		rot_points[i].p3_uvl.v = (i&2) ? 1.0f : 0.0f;

		pntlist[i] = &rot_points[i];
	}

	// And draw!!
	rend_SetTextureType( TT_LINEAR );

	if( color != -1 )
	{
		rend_SetLighting( LS_FLAT_GOURAUD );
		rend_SetFlatColor( color );
	}

	g3_DrawPoly( 4, pntlist, bm );
}

// Draws a bitmap on a specific plane.  Also does rotation.  Angle of rotation is passed as 'rot_angle'
void g3_DrawPlanarRotatedBitmap(vector *pos,vector *norm,angle rot_angle,float width,float height,int bm)
{
	matrix rot_matrix;
	vm_VectorToMatrix( &rot_matrix, norm, NULL, NULL );
	vm_TransposeMatrix( &rot_matrix );

	matrix twist_matrix;
	vm_AnglesToMatrix( &twist_matrix, 0, 0, rot_angle );

	float w = width;
	float h = height;

	vector rot_vectors[4];
	rot_vectors[0] =  (twist_matrix.rvec * -w);
	rot_vectors[0] += (twist_matrix.uvec * h); 

	rot_vectors[1] =  (twist_matrix.rvec * w);
	rot_vectors[1] += (twist_matrix.uvec * h);

	rot_vectors[2] =  (twist_matrix.rvec * w);
	rot_vectors[2] -= (twist_matrix.uvec * h);

	rot_vectors[3] =  (twist_matrix.rvec * -w);
	rot_vectors[3] -= (twist_matrix.uvec * h);

	int i;
	for( i = 0; i < 4; ++i )
	{	
		vector temp_vec = rot_vectors[i];
		vm_MatrixMulVector( &rot_vectors[i], &temp_vec, &rot_matrix );
	}

	g3Point rot_points[8],*pntlist[8];
	for( i = 0; i < 4; ++i )
	{		
		rot_vectors[i] += *pos;

		g3_RotatePoint( &rot_points[i], &rot_vectors[i] );
		rot_points[i].p3_flags |= PF_UV|PF_L;
		rot_points[i].p3_l     = 1.0f;

		pntlist[i] = &rot_points[i];
	}

	rot_points[0].p3_u = 0.0f;
	rot_points[0].p3_v = 0.0f;

	rot_points[1].p3_u = 1.0f;
	rot_points[1].p3_v = 0.0f;

	rot_points[2].p3_u = 1.0f;
	rot_points[2].p3_v = 1.0f;

	rot_points[3].p3_u = 0.0f;
	rot_points[3].p3_v = 1.0f;

	// And draw!!
	rend_SetTextureType( TT_LINEAR );
	g3_DrawPoly( 4, pntlist, bm );
}


//Draw a wireframe box aligned with the screen.  Used for the editor.
//Parameters:	color - the color to draw the lines
//					pnt - the center point
//					rad - specifies the width/2 & height/2 of the box
void g3_DrawBox(ddgr_color color,g3Point *pnt,float rad)
{
	if (! (pnt->p3_codes & CC_BEHIND))
	{
		if (! (pnt->p3_flags & PF_PROJECTED))
			g3_ProjectPoint(pnt);

		float w,h;

		w = rad * Matrix_scale.x * Window_w2 / pnt->p3_z;
		h = rad * Matrix_scale.y * Window_h2 / pnt->p3_z;

		rend_DrawLine(round(pnt->p3_sx-w),round(pnt->p3_sy-h),round(pnt->p3_sx+w),round(pnt->p3_sy-h));
		rend_DrawLine(round(pnt->p3_sx+w),round(pnt->p3_sy-h),round(pnt->p3_sx+w),round(pnt->p3_sy+h));
		rend_DrawLine(round(pnt->p3_sx+w),round(pnt->p3_sy+h),round(pnt->p3_sx-w),round(pnt->p3_sy+h));
		rend_DrawLine(round(pnt->p3_sx-w),round(pnt->p3_sy+h),round(pnt->p3_sx-w),round(pnt->p3_sy-h));
	}
}

// Sets the triangulation test to on or off
void g3_SetTriangulationTest (int state)
{
	Triangulate_test = state;
}

#endif