Utils/parkgrab/tpage.cpp

@@ -0,0 +1,857 @@
+/*=========================================================================
+
+	FILENAME.CPP	
+
+	Author:  Gary Liddon @
+	Created:
+	Project:
+	Purpose:
+
+	Copyright (c) 1997 Climax Development Ltd
+
+===========================================================================*/
+
+/*----------------------------------------------------------------------
+	Includes
+	-------- */
+
+/*	Std Lib
+	------- */
+#include <algorithm>
+#include "conio.h"
+
+/*	Glib
+	---- */
+#include "gutils.h"
+
+/*	Local
+	----- */
+#include "tpage.h"
+#include "grect.h"
+
+/*	Graphics
+	-------- */
+
+/*----------------------------------------------------------------------
+	Tyepdefs && Defines
+	------------------- */
+
+using namespace std;
+
+
+/*----------------------------------------------------------------------
+	Structure defintions
+	-------------------- */
+struct TPInfo
+{
+	int		XAlign;
+	int		TpWidth;
+	int		BorderX;
+	int		BorderY;
+};
+
+/*	Information about where I can place this frame in the Tpage
+	----------------------------------------------------------- */
+/*----------------------------------------------------------------------
+	Vars
+	---- */
+static TPInfo const	InfStruct[TP_NUM_OF_TP_TYPES]=
+{
+	{1,256,1,1},			/* TP_4 */
+	{2,512,2,1},			/* TP_8 */
+	{4,256,4,1},			/* TP_16 */
+	{0,0,0,0},				/* TP_SCREEN */
+	{16*4,1024*4,0,0},		/* TP_PAL */
+};
+
+/*----------------------------------------------------------------------
+	Function Prototypes
+	------------------- */
+
+/*----------------------------------------------------------------------
+	Vars
+	---- */
+int	TPRect::W2Alloc=1;
+int	TPRect::H2Alloc=1;
+
+/*----------------------------------------------------------------------
+	Data
+	---- */
+
+/*----------------------------------------------------------------------
+	Function:	
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+VRAM::VRAM(int nTpWidth,int nTpHeightInPixels)
+{
+	Big2Little=false;
+	RotateEveryEmpty=false;
+
+
+	TpWidth=-1;
+	TpHeightInPixels=-1;
+
+	Clear(nTpWidth,nTpHeightInPixels);
+}
+
+void VRAM::Clear(int nTpWidth,int nTpHeightInPixels)
+{
+	if (nTpWidth >= 0 )
+		TpWidth=nTpWidth;
+
+	if (nTpHeightInPixels >= 0)
+		TpHeightInPixels=nTpHeightInPixels;
+
+	InitEmpty(0,0,TpWidth*256,TpHeightInPixels);
+}
+
+
+/*----------------------------------------------------------------------
+	Function:	void VRAM::InitEmpty(void)
+	Purpose:	Initialise the VRAM as empty
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+void VRAM::InitEmpty(int vX,int vY,int nW,int nH)
+{
+	const int	Width16=256;
+	const int	Height16=256;
+	
+	W=nW;
+	H=nH;
+	X=vX;
+	Y=vY;
+
+	VRAMWidthPages=W/Width16;
+	VRAMHeightPages=H/Height16;
+
+	if (!VRAMHeightPages)
+	{
+		VRAMHeightPages = 1;
+	}
+
+	NumOfTPages=VRAMWidthPages*VRAMHeightPages;
+
+	VecOfPages.resize(NumOfTPages,TPRectList());
+
+	Unused.reserve(4000);
+	Used.reserve(2000);
+
+	Unused.resize(0);
+	Used.resize(0);
+
+	for (int f=0;f<NumOfTPages;f++)
+		VecOfPages[f].resize(0);
+
+	for (int y=0;y<VRAMHeightPages;y++)
+		for (int x=0;x<VRAMWidthPages;x++)
+			AddEmpty((x*Width16)+vX,(y*Height16)+vY,Width16,Height16);
+}
+
+/*----------------------------------------------------------------------
+	Function:	bool TryNFit(TPRectList & TpList)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+bool VRAM::TryNFit(TPRectList & TpList,TPRect & ThisRect)
+{
+	bool		Done=false;
+
+	TPRectList::iterator	f;
+
+
+	for (f=TpList.begin();f!=TpList.end();f++)
+		{
+		TPRect &	BlankRect = *f;
+
+		if (TryRect(BlankRect,ThisRect))
+			return(true);
+		else
+			{
+			if (RotateEveryEmpty && CanRotate(ThisRect))
+				{
+				ThisRect.SetRotate(!ThisRect.GetRotate());
+		
+				if (TryRect(BlankRect,ThisRect))
+					return(true);
+				else
+					ThisRect.SetRotate(!ThisRect.GetRotate());
+				}
+			}
+		}
+		
+	return(false);
+}
+
+void VRAM::PosFromTPrect(TPRect & ThisRect,POS_INFO & Pi)
+{
+	TPInfo const *		Tpi;
+	int					WorkingWidth;
+
+	Tpi=&InfStruct[ThisRect.TypeOfPage];
+	Pi.XAlign=Tpi->XAlign;
+
+	WorkingWidth=GU_AlignVal(ThisRect.W,Pi.XAlign);
+
+	Pi.MinX=Tpi->BorderX;
+	Pi.MinY=Tpi->BorderY;
+	Pi.MaxX=W-Tpi->BorderX-WorkingWidth;
+	Pi.MaxY=H-Tpi->BorderY-ThisRect.H;
+
+	Pi.TpWidthPix=Tpi->TpWidth;
+
+	Pi.MinXTp=Tpi->BorderX;
+	Pi.MaxXTp=Tpi->TpWidth-Tpi->BorderX-WorkingWidth;
+
+	Pi.MinYTp=Tpi->BorderY;
+	Pi.MaxYTp=(256-Tpi->BorderY)-ThisRect.H;
+}
+
+bool VRAM::TryRect(TPRect & BlankRect,TPRect & ThisRect)
+{
+	POS_INFO		Pi;
+	PosFromTPrect(ThisRect,Pi);
+
+	int	MinTpX=Pi.MinXTp+(BlankRect.X/Pi.TpWidthPix)*Pi.TpWidthPix;
+	int	MaxTpX=Pi.MaxXTp+(BlankRect.X/Pi.TpWidthPix)*Pi.TpWidthPix;
+	int	MinTpY=Pi.MinYTp+(BlankRect.Y/256)*256;
+	int	MaxTpY=Pi.MaxYTp+(BlankRect.Y/256)*256;
+
+	/* Move to avoid edges of the map */
+	int		MinX = MinTpX > Pi.MinX ? MinTpX : Pi.MinX;
+	int		MaxX = MaxTpX < Pi.MaxX ? MaxTpX : Pi.MaxX;
+	int		MinY = MinTpY > Pi.MinY ? MinTpY : Pi.MinY;
+	int		MaxY = MaxTpY < Pi.MaxY ? MaxTpY : Pi.MaxY;
+
+	int ThisX=GU_AlignVal(BlankRect.X,Pi.XAlign);
+	int ThisY=BlankRect.Y;
+
+	if (ThisX<MinX)
+		ThisX=MinX;
+
+	if (ThisX>MaxX)
+		return(false);
+
+	if (ThisY<MinY)
+		ThisY=MinY;
+
+	if (ThisY>MaxY)
+		return(false);
+
+	ThisRect.SetXY(ThisX,ThisY);
+
+	if (!InColisionWithUsed(ThisRect))
+		{
+		RemovedFromUnused(ThisRect);
+		AddToUsed(ThisRect);
+		return(true);
+		}
+
+	return(false);
+}
+
+/*----------------------------------------------------------------------
+	Function:	TPRect VRAM::AllocVRAM(TPageType nType,int nW,int nH,bool Rotated)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+
+class Predicate
+{
+public:
+	bool operator()(TPRect const & R1,TPRect const & R2) const
+		{
+		u32 R1Val=(R1.H<<16)|(R1.W);
+		u32 R2Val=(R2.H<<16)|(R2.W);
+		return (R1Val<R2Val);
+		}
+};
+
+class Predicate2
+{
+public:
+	bool operator()(TPRect const & R1,TPRect const & R2) const
+		{
+		u32 R1Val=(R1.H<<16)|(R1.W);
+		u32 R2Val=(R2.H<<16)|(R2.W);
+		return (R1Val>R2Val);
+		}
+};
+
+/*----------------------------------------------------------------------
+	Function:	TPRect VRAM::AllocVRAM(TpRectVec & RectVec)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+bool VRAM::AllocVRAM(TPRectVec & RectVec,bool nRotateEveryEmpty,bool nBig2Little,bool nWiderThanHigher)
+{
+	int			f;
+
+	RotateEveryEmpty=nRotateEveryEmpty;
+	Big2Little=nBig2Little;
+	WiderThanHigher=nWiderThanHigher;
+
+	if (WiderThanHigher)
+		{
+		for (f=0;f<RectVec.size();f++)
+			{
+			if ((RectVec[f].H > RectVec[f].W) && CanRotate(RectVec[f]))
+				RectVec[f].SetRotate(!RectVec[f].GetRotate());
+			}
+		}
+
+	if (!Big2Little)
+		std::sort(RectVec.begin(),RectVec.end(),Predicate());
+	else
+		std::sort(RectVec.begin(),RectVec.end(),Predicate2());
+
+	bool	AllocedEverything=true;
+
+	for (f=0;f<RectVec.size();f++)
+		{
+		if (!AllocVRAM(RectVec[f]))
+			{
+			AllocedEverything=false;
+			cout<<"Couldn't alloc "<<RectVec[f].W<<","<<RectVec[f].H<<endl;
+			}
+		}
+
+	return(AllocedEverything);
+}
+
+/*----------------------------------------------------------------------
+	Function:	void VRAM::AllocVRAM(TPageType nType,int nW,int nH)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+
+bool VRAM::AllocVRAM(TPRect & OriginalRect)
+{
+	bool	Done;
+	TPRect	ThisRect;
+
+	ThisRect=OriginalRect;
+
+	Done=false;
+
+	for (int Page=0;Page<NumOfTPages && !Done;Page++)
+		{
+		VecOfPages[Page].sort();
+
+		TPRect::SetAllocWH(ThisRect.W,ThisRect.H);
+
+		if (!TryNFit(VecOfPages[Page],ThisRect))
+			{
+			if (CanRotate(ThisRect))
+				{
+				ThisRect.SetRotate(!ThisRect.GetRotate());
+
+				VecOfPages[Page].sort();
+				TPRect::SetAllocWH(ThisRect.W,ThisRect.H);
+
+				if (!TryNFit(VecOfPages[Page],ThisRect))
+					ThisRect.SetRotate(!ThisRect.GetRotate());
+				else
+					Done=true;
+				}
+			}
+		else
+			Done=true;
+		}
+
+
+	if (Done)
+		{
+		OriginalRect=ThisRect;
+		OriginalRect.SetAlloced(true);
+		return(true);
+		}
+	else
+		{
+		OriginalRect.SetAlloced(false);
+		return(false);
+		}
+}
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+bool VRAM::CanRotate(TPRect & ThisRect)
+{
+	if (ThisRect.GetDontRotate())
+		return(false);
+
+	switch (ThisRect.TypeOfPage)
+		{
+		case TP_PAL:
+			return(false);
+
+		case TP_4:
+		case TP_8:
+		case TP_16:
+			return(true);
+
+		case TP_SCREEN:
+		case TP_NUM_OF_TP_TYPES:
+		default:
+			Error(ERR_FATAL,"Not catered for");
+			return(false);
+		}
+}
+
+/*----------------------------------------------------------------------
+	Function:	void VRAM::AllocVRAM(TPageType nType,int nW,int nH)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+void VRAM::RectFromTpRect(Rect & R,TPRect const & ThisRect)
+{
+	R.W=ThisRect.W;
+	R.H=ThisRect.H;
+	R.X=ThisRect.X;
+	R.Y=ThisRect.Y;
+}
+
+void VRAM::RemovedFromUnused(TPRect const & ThisRect)
+{
+	RectVec		Result;
+	Rect		NewRect;
+	int			f;
+
+	RectFromTpRect(NewRect,ThisRect);
+
+	int		ColidedWith=0;
+
+	for ( f=0;f<Unused.size();f++)
+		{
+		Rect	UnusedRect;
+		
+		RectFromTpRect(UnusedRect,Unused[f]);
+
+		if (UnusedRect.IsColiding(ThisRect) )
+			{
+			CutRect(UnusedRect,ThisRect,Result);
+			ColidedWith++;
+			}	
+		else
+			Result.push_back(UnusedRect);
+		}
+
+	Unused.resize(0);
+
+	for (f=0;f<NumOfTPages;f++)
+		VecOfPages[f].resize(0);
+	
+	for (f=0;f<Result.size();f++)
+		AddEmpty(Result[f].X,Result[f].Y,Result[f].W,Result[f].H);
+}
+
+void VRAM::AddEmpty(int x,int y,int w,int h)
+{
+	Unused.resize(Unused.size()+1);
+
+	TPRect & ThisRect=(Unused[Unused.size()-1]);
+
+	ThisRect.TypeOfPage=TP_4;
+	ThisRect.W=w;
+	ThisRect.H=h;
+	ThisRect.X=x;
+	ThisRect.Y=y;
+
+	int	TpNum=(x/256)+((y/256)*VRAMWidthPages);
+
+
+
+	VecOfPages[TpNum].insert(VecOfPages[TpNum].end(),ThisRect);
+}
+
+void VRAM::AddToUsed(TPRect const & ThisRect)
+{
+
+	Used.push_back(ThisRect);
+}
+
+
+bool VRAM::InColisionWithUsed(TPRect const & R)
+{
+	for (int f=0;f<Used.size();f++)
+		{
+		if (R.IsColiding(Used[f]))
+			return(true);
+		}
+
+	return(false);
+}
+
+/*----------------------------------------------------------------------
+	Function:	bool VRAM::CheckValidAlloc(TPageType nType,int nW,int nH)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+bool VRAM::CheckValidAlloc(TPageType nType,int nW,int nH)
+{
+	return(true);
+}
+
+/*----------------------------------------------------------------------
+	Function:	int VRAM::GetMaxWidthTp(TPageType nType)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+int VRAM::GetMaxWidthTp(TPageType nType)
+{
+	int		RetVal;
+
+	switch (nType)
+		{
+		case TP_4:
+			RetVal=1;
+			break;
+
+		case TP_8:
+			RetVal=2;
+			break;
+
+		case TP_16:
+			RetVal=4;
+			break;
+
+		case TP_SCREEN:
+			RetVal=256;
+			break;
+
+		default:
+			RetVal=-1;
+			Error(ERR_FATAL,"Illegal tpage type");
+			break;
+		}
+
+	return(RetVal);
+}
+
+/*----------------------------------------------------------------------
+	Function:	int VRAM::GetXAlign(TPageType nType)
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+int VRAM::GetXAlign(TPageType nType)
+{
+	int		RetVal;
+
+	switch (nType)
+		{
+		case TP_4:
+			RetVal=1;
+			break;
+
+		case TP_8:
+			RetVal=2;
+			break;
+
+		case TP_16:
+			RetVal=4;
+			break;
+		
+		case TP_PAL:
+			RetVal=16*4;
+			break;
+
+		case TP_SCREEN:
+			RetVal=4;
+			break;
+		
+		default:
+			RetVal=-1;
+			Error(ERR_FATAL,"Illegal tpage type");
+			break;
+		}
+
+	return(RetVal);
+}
+
+/*----------------------------------------------------------------------
+	Function:	
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+
+/*----------------------------------------------------------------------
+	Function:	
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+TPRect & VRAM::NewItem(TPRectVec & TPRects)
+{
+	TPRects.resize(TPRects.size()+1);
+	return(TPRects[TPRects.size()-1]);
+}
+
+/*----------------------------------------------------------------------
+	Function:	
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+TPRect::TPRect(void)
+{	
+	InitRect();
+}
+
+void TPRect::InitRect(void)
+{
+	X=0;
+	Y=0;
+	W=0;
+	H=0;
+	TypeOfPage=TP_4;
+	Rotated=false;
+	Alloced=false;
+	DontRotate=false;
+}
+
+TPRect::TPRect(TPageType nType,int nW,int nH)
+{
+	int WidthMul;
+
+	InitRect();
+
+	WidthMul=GetWidthMul(nType);
+
+	W=nW*WidthMul;
+	H=nH;
+	TypeOfPage=nType;
+}
+
+int TPRect::GetWidthMul(TPageType nType)
+{
+	int WidthMul;
+
+	switch (nType)
+		{
+		case TP_4:
+			WidthMul=1;
+			break;
+
+		case TP_8:
+			WidthMul=2;
+			break;
+
+		case TP_16:
+		case TP_SCREEN:
+		case TP_PAL:
+			WidthMul=4;
+			break;
+
+		case TP_NUM_OF_TP_TYPES:
+		default:
+			Error(ERR_FATAL,"Can't alloc type TP_NUM_OF_TP_TYPES");
+			break;
+		}
+	return (WidthMul);
+}
+
+void TPRect::Set(TPageType nType,int nX,int nY,int nW,int nH)
+{
+	TypeOfPage=nType;
+	X=nX;
+	Y=nY;
+	W=nW*GetWidthMul(nType);
+	H=nH;
+}
+
+void TPRect::SetXY(int nX,int nY)
+{
+	X=nX;
+	Y=nY;
+}
+
+u32	TPRect::GetId(void) const
+{
+	int Colis=0;
+
+	int	PageNum=(X/256)+((Y/256)*16);
+
+	if ((X/256) != ((X+W2Alloc-1)/256))
+		Colis|=1;
+
+	if ((Y/256) != ((Y+H2Alloc-1)/256))
+		Colis|=2;
+				
+	return ((Colis<<24)|(PageNum<<16)|((Y&0xff)<<8)|(X&0xff));
+}
+
+bool TPRect::SetRotate(bool Rot)
+{
+	bool	RetBool=Rotated;
+
+	if (Rot != RetBool)
+		{
+		W/=GetWidthMul(TypeOfPage);
+		int	Temp=W;
+		W=H;
+		H=Temp;
+		W*=GetWidthMul(TypeOfPage);
+		}
+
+	Rotated=Rot;
+	return(RetBool);
+}
+
+
+void VRAM::getUnusedSpace(TPRectVec & unusedBoxes)
+{
+	int			vX=X;
+	int			vY=Y;
+	const int	Width16=256;
+	const int	Height16=256;
+
+	for (int y=0;y<VRAMHeightPages;y++)
+		for (int x=0;x<VRAMWidthPages;x++)
+			{
+			TPRect		thisRect;
+			bool		foundRect;
+
+			foundRect=false;
+
+			for (int f=1;f<255 && !foundRect;f++)
+				{
+				int		boxBaseY;
+				int		boxHeight;
+
+				boxBaseY=f;
+				boxHeight=255-f;
+
+				thisRect.X=(x*Width16)+vX;
+				thisRect.Y=(y*Height16)+vY+boxBaseY;
+				thisRect.W=Width16;
+				thisRect.H=boxHeight;
+
+				if (!InColisionWithUsed(thisRect))
+					foundRect=true;
+				}
+			
+			if (foundRect)
+				unusedBoxes.push_back(thisRect);
+			}
+}
+
+
+int VRAM::GetNumOfUsedPages()
+{
+	int			Used=0;
+	int			vX=X;
+	int			vY=Y;
+	const int	Width16=256;
+	const int	Height16=256;
+
+	for (int y=0;y<VRAMHeightPages;y++)
+		for (int x=0;x<VRAMWidthPages;x++)
+			{
+			TPRect		ThisRect;
+			ThisRect.X=(x*Width16)+vX;
+			ThisRect.Y=(y*Height16)+vY;
+			ThisRect.W=Width16;
+			ThisRect.H=Height16;
+
+			if (InColisionWithUsed(ThisRect))
+				Used++;
+			}
+	return(Used);
+}
+
+
+bool TPRect::IsAlloced(void) const
+{
+	return(Alloced);
+}
+
+void TPRect::SetAlloced(bool nAlloced)
+{
+	Alloced=nAlloced;
+}
+
+int VRAM::GetNumOfItems()
+{
+	return(Used.size());
+}
+
+void TPRect::InitFromFrame(Frame const & Fr)
+{
+	/* !!!!! Make this support other bit widths */
+
+	W=Fr.GetWidth();
+	H=Fr.GetHeight();
+	
+	if (Fr.GetNumOfCols() <= 16)
+		TypeOfPage=TP_4;
+	else if (Fr.GetNumOfCols() <= 256)
+		TypeOfPage=TP_8;
+	else
+		Error(ERR_FATAL,"Only 4 & 8 bit supported right now");
+
+	W*=GetWidthMul(TypeOfPage);
+}
+
+
+TPageType TPRect::convertTo16Bit(void)
+{
+	TPageType		oldType;
+
+	switch (TypeOfPage)
+		{
+		case TP_4:
+//			W=GU_AlignVal(W,4)/4;
+			break;
+
+		case TP_8:
+//			W=GU_AlignVal(W,2)/2;
+			break;
+		default:
+			Error(ERR_FATAL,"Only 4 & 8 bit supported right now");
+			break;
+		}
+
+	oldType=TypeOfPage;
+	TypeOfPage=TP_16;
+
+	return(oldType);
+}
+
+void TPRect::convertFrom16Bit(TPageType newType)
+{
+	switch (newType)
+		{
+		case TP_4:
+//			W=W*4;
+			break;
+
+		case TP_8:
+//			W=W*2;
+			break;
+		default:
+			Error(ERR_FATAL,"Only 4 & 8 bit supported right now");
+			break;
+		}
+
+	TypeOfPage=newType;
+}
+
+/*===========================================================================
+ end */
+
+