/* drawing.m */
#include "idbsp.h"

/* id 			window_i, view_i; */
STORAGE *window_i,*view_i;
float		scale = 0.125;
NXRect		worldbounds;

/*
================
=
= IDRectFromPoints
=
= Makes the rectangle just touch the two points
=
================
*/

void IDRectFromPoints(NXRect *rect, NXPoint const *p1, NXPoint const *p2 )
{
/* return a rectangle that encloses the two points */
	if (p1->x < p2->x)
	{
		rect->origin.x = p1->x;
		rect->size.width = p2->x - p1->x + 1;
	}
	else
	{
		rect->origin.x = p2->x;
		rect->size.width = p1->x - p2->x + 1;
	}

	if (p1->y < p2->y)
	{
		rect->origin.y = p1->y;
		rect->size.height = p2->y - p1->y + 1;
	}
	else
	{
		rect->origin.y = p2->y;
		rect->size.height = p1->y - p2->y + 1;
	}
}


/*
==================
=
= IDEnclosePoint
=
= Make the rect enclose the point if it doesn't allready
=
==================
*/

void IDEnclosePoint (NXRect *rect, NXPoint const *point)
{
	float	right, top;

	right = rect->origin.x + rect->size.width - 1;
	top = rect->origin.y + rect->size.height - 1;

	if (point->x < rect->origin.x)
		rect->origin.x = point->x;
	if (point->y < rect->origin.y)
		rect->origin.y = point->y;
	if (point->x > right)
		right = point->x;
	if (point->y > top)
		top = point->y;

	rect->size.width = right - rect->origin.x + 1;
	rect->size.height = top - rect->origin.y + 1;
}


/*
===========
=
= BoundLineStore
=
===========
*/

/* void BoundLineStore (id lines_i, NXRect *r) */
void BoundLineStore(STORAGE *lines_i,NXRect *r)
{
	int				i,c;
	worldline_t		*line_p;

/*	c = [lines_i count]; */
	c = lines_i->count;
	if (!c)
		Error ("BoundLineStore: empty list");

/* line_p = [lines_i elementAt:0]; */
	line_p = lines_i->data;
	IDRectFromPoints (r, &line_p->p1, &line_p->p2);

	for (i=1 ; i<c ; i++)
	{
/*		line_p = [lines_i elementAt:i]; */
		line_p = (worldline_t *)lines_i->data + i;
		IDEnclosePoint (r, &line_p->p1);
		IDEnclosePoint (r, &line_p->p2);
	}
}


/*
===========
=
= DrawLineStore
=
= Draws all of the lines in the given storage object
=
===========
*/

/* void DrawLineStore (id lines_i) */
void DrawLineStore(STORAGE *lines_i)
{
#if 0
	int				i,c;
	worldline_t		*line_p;

	if (!draw)
		return;

/*	c = [lines_i count]; */
	c = lines_i->count;

	for (i=0 ; i<c ; i++)
	{
/*		line_p = [lines_i elementAt:i]; */
		line_p = (worldline_t *)lines_i->data + i;
		PSmoveto (line_p->p1.x, line_p->p1.y);
		PSlineto (line_p->p2.x, line_p->p2.y);
		PSstroke ();
	}
	NXPing ();
#endif
}

/*
===========
=
= DrawLine
=
= Draws all of the lines in the given storage object
=
===========
*/

void DrawLineDef (maplinedef_t *ld)
{
#if 0
	mapvertex_t		*v1, *v2;

	if (!draw)
		return;
/*
	v1 = [mapvertexstore_i elementAt: ld->v1];
	v2 = [mapvertexstore_i elementAt: ld->v2];
*/
	v1 = mapvertexstore_i->data + ld->v1;
	v2 = mapvertexstore_i->data + ld->v2;
	PSmoveto (v1->x, v1->y);
	PSlineto (v2->x, v2->y);
	PSstroke ();
	NXPing ();
#endif
}


/*
===========
=
= DrawMap
=
===========
*/

void DrawMap (void)
{
	NXRect	scaled;

	BoundLineStore (linestore_i, &worldbounds);
	worldbounds.origin.x -= 8;
	worldbounds.origin.y -= 8;
	worldbounds.size.width += 16;
	worldbounds.size.height += 16;

#if 0
	if (!draw)
		return;

	scaled.origin.x = 300;
	scaled.origin.y = 80;
	scaled.size.width = worldbounds.size.width*scale;
	scaled.size.height = worldbounds.size.height* scale;
/*
	window_i =
	[[Window alloc]
		initContent:	&scaled
		style:			NX_TITLEDSTYLE
		backing:		NX_RETAINED
		buttonMask:		0
		defer:			NO
	];

	[window_i display];
	[window_i orderFront: nil];
	view_i = [window_i contentView];

	[view_i
		setDrawSize:	worldbounds.size.width
		:				worldbounds.size.height];
	[view_i
		setDrawOrigin:	worldbounds.origin.x
		: 				worldbounds.origin.y];

	[view_i lockFocus];
	PSsetgray (NX_BLACK);
	DrawLineStore (linestore_i);
*/
#endif
}


/*
===========
=
= EraseWindow
=
===========
*/

void EraseWindow (void)
{
#if 0
	if (!draw)
		return;

	NXEraseRect (&worldbounds);
	NXPing ();
#endif
}


/*
============================
=
= DrawDivLine
=
============================
*/

void DrawDivLine (divline_t *div)
{
#if 0
	float	vx,vy, dist;

	if (!draw)
		return;

	PSsetgray (NX_BLACK);

	dist = sqrt (pow(div->dx,2)+pow(div->dy,2));
	vx = div->dx/dist;
	vy = div->dy/dist;

	dist = MAX(worldbounds.size.width,worldbounds.size.height);

	PSmoveto (div->pt.x - vx*dist, div->pt.y - vy*dist);
	PSlineto (div->pt.x + vx*dist, div->pt.y + vy*dist);
	PSstroke ();
	NXPing ();
#endif
}