Utils/MkLevel/Layers/MkLevelLayer.h

@@ -0,0 +1,35 @@
+/******************/
+/*** Layer Core ***/
+/******************/
+
+#ifndef	__MKLEVEL_LAYER_HEADER__
+#define	__MKLEVEL_LAYER_HEADER__
+
+#include	<Vector>
+
+#include	"..\MkLevel.h"
+#include	"..\..\MapEdit\LayerDef.h"
+#include	"..\..\mapedit\ExportHdr.h"
+
+
+/*****************************************************************************/
+class	CMkLevelLayer
+{
+public:
+
+virtual		void	PreProcess(CMkLevel *Core)=0;
+virtual		void	Process(CMkLevel *Core)=0;
+virtual		int		Write(FILE *File,const char *LayerName,const char *MapName)=0;
+
+			bool	IsType(int _Type,int _SubType)			{return(Type==_Type && SubType==_SubType);}
+
+protected:
+			int		Type;
+			int		SubType;
+			int		Width;
+			int		Height;
+};
+
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayer3d.cpp

@@ -0,0 +1,267 @@
+/****************/
+/*** Layer 3d ***/
+/****************/
+
+#include	<Davelib.h>
+#include	<List2d.h>
+
+#include	"..\MkLevel.h"
+#include	"MkLevelLayer3d.h"
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayer3d::PreProcess(CMkLevel *Core)
+{
+int			Width=InMap.GetWidth();
+int			Height=InMap.GetHeight();
+
+		OutMap.SetSize(Width,Height);
+
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sExpLayerTile	&InElem=InMap.Get(X,Y);
+				sMkLevelElem	&OutElem=OutMap.Get(X,Y);
+
+				OutElem.Elem=0;
+				if (InElem.Tile)
+				{ // Not Blank Tile
+					OutElem.Elem=Core->AddTile3d(InElem);
+				}
+			}
+		}
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayer3d::Process(CMkLevel *Core)
+{
+/*
+int				Width=InMap.GetWidth();
+int				Height=InMap.GetHeight();
+int				i,ListSize;
+
+		TriList.SetTexGrab(Core->GetTexGrab());
+//!!!		TexGrab.AllowRotate(true);
+		TexGrab.AllowRotate(false);
+//!!!		TexGrab.ShrinkToFit(true);
+		TexGrab.ShrinkToFit(false);
+
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sExpLayerTile	&ThisElem=InMap.Get(X,Y);
+				sMkLevelElem	&OutElem=OutMap.Get(X,Y);
+					
+				OutElem.Elem=TriList.GetFaceCount();
+
+				if (ThisElem.Tile)
+				{ // Not Blank Tile
+					sExpTile		&InTile=Core->GetTile(ThisElem);
+// Build Sorted List
+					CList<CFace>	SortList;
+					CList<float>	ZPosList;
+					if (InTile.TriCount)
+					{
+						for (i=0; i<InTile.TriCount; i++)
+						{
+							int		ListPos;
+							CFace	&ThisFace=CMkLevel::AllTriList[InTile.TriStart+i];
+							float	ThisZPos;
+							
+							ThisZPos=ThisFace.vtx[0].z;
+							if (ThisZPos>ThisFace.vtx[1].z) ThisZPos=ThisFace.vtx[1].z;
+							if (ThisZPos>ThisFace.vtx[2].z) ThisZPos=ThisFace.vtx[2].z;
+							
+							ListSize=SortList.size();
+							for (ListPos=0; ListPos<ListSize; ListPos++)
+							{
+								if (ZPosList[ListPos]<ThisZPos) break;
+							}
+							SortList.insert(ListPos,ThisFace);
+							ZPosList.insert(ListPos,ThisZPos);
+							// Flip 3d tiles
+							CFace	&F=SortList[ListPos];
+							bool	SwapPnt=false;
+
+							if (ThisElem.Flags & PC_TILE_FLAG_MIRROR_X)	
+							{
+								F.vtx[0].x=-F.vtx[0].x;
+								F.vtx[1].x=-F.vtx[1].x;
+								F.vtx[2].x=-F.vtx[2].x;
+								SwapPnt^=1;
+							}
+
+							if (ThisElem.Flags & PC_TILE_FLAG_MIRROR_Y)	
+							{
+								F.vtx[0].y	=1.0-F.vtx[0].y;
+								F.vtx[1].y	=1.0-F.vtx[1].y;
+								F.vtx[2].y	=1.0-F.vtx[2].y;
+								SwapPnt^=1;
+							}
+							if (SwapPnt)
+							{
+								Vector3	TmpV=F.vtx[0];
+								F.vtx[0]=F.vtx[1];
+								F.vtx[1]=TmpV;
+								sUV		TmpUV=F.uvs[0];
+								F.uvs[0]=F.uvs[1];
+								F.uvs[1]=TmpUV;
+							}
+
+						}
+
+					}
+					else
+					{ // create flat tile
+						for (int i=0; i<2; i++)
+						{
+							FlatFace[i].Mat=OutElem.TexID;
+							SortList.push_back(FlatFace[i]);
+						}
+					}
+
+					ListSize=SortList.size();
+// Sort out Flipping
+					for (i=0; i<ListSize; i++)
+					{
+						CFace	&F=SortList[i];
+
+// Offset Vtx's
+						for (int p=0; p<3; p++) 
+						{
+							F.vtx[p].x	+=(float)X;
+							F.vtx[p].y	-=(float)Y;
+						}
+						F.ID=i;
+//						printf("%i\n",F.ID);
+						TriList.AddFace(F);
+
+					}
+				}
+			}
+		}
+*/
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayer3d::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+int				ThisPos=ftell(File);
+/*
+int				Width=OutMap.GetWidth();
+int				Height=OutMap.GetHeight();
+sLayerHdr		LayerHdr;
+sLayer3d		Hdr3d;
+vector<sVtx>	OutVtxList;
+
+		TriList.Process();
+		ProcessVtxList(TriList.GetVtxList(),OutVtxList);
+
+		LayerHdr.Type=Type;
+		LayerHdr.SubType=SubType;
+		LayerHdr.Width=Width;
+		LayerHdr.Height=Height;
+		fwrite(&LayerHdr,sizeof(sLayerHdr),1,File);
+
+int	Pos3d=ftell(File);
+		fwrite(&Hdr3d,sizeof(sLayer3d),1,File);
+
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sMkLevelElem	&OutElem=OutMap.Get(X,Y);	
+
+				fwrite(&OutElem.Elem,sizeof(u16),1,File);
+			}
+		}
+
+		PadFile(File);
+		Hdr3d.TriCount=TriList.GetFaceCount();
+		Hdr3d.TriList=TriList.WriteTriList(File)-ThisPos;
+		Hdr3d.QuadCount=0;
+		Hdr3d.QuadList=TriList.WriteQuadList(File)-ThisPos;
+		Hdr3d.VtxCount=OutVtxList.size();
+		Hdr3d.VtxList=TriList.WriteVtxList(File,OutVtxList)-ThisPos;
+
+		printf("T:%i V:%i\t",Hdr3d.TriCount,Hdr3d.VtxCount);
+		printf("sTri %i\tFT3 %i\n",Hdr3d.TriCount*16,Hdr3d.TriCount*34);
+int	RetPos=ftell(File);
+		fseek(File,Pos3d,SEEK_SET);
+		fwrite(&Hdr3d,sizeof(sLayer3d),1,File);
+		fseek(File,RetPos,SEEK_SET);
+*/
+		return(ThisPos);
+}
+
+/*****************************************************************************/
+void	CMkLevelLayer3d::ProcessVtxList(vector<sVtx> const &InList,vector<sVtx> &OutList)
+{
+int		i,ListSize=InList.size();
+//int		XMin,XMax,YMin,YMax;
+sVtx	Ofs;
+		OutList.resize(ListSize);
+		if (!ListSize) return;
+/*
+		XMin=XMax=InList[0].vx;
+		YMin=YMax=InList[0].vy;
+// Find Min/Max
+		for (i=1; i<ListSize; i++)
+		{
+//			printf("%i %i %i\n",InList[i].vx,InList[i].vy,InList[i].vz);
+			if (XMin>InList[i].vx) XMin=InList[i].vx;
+			if (XMax<InList[i].vx) XMax=InList[i].vx;
+			if (YMin>InList[i].vy) YMin=InList[i].vy;
+			if (YMax<InList[i].vy) YMax=InList[i].vy;
+		}
+
+//		Ofs.vx=-32768-XMin;
+//		Ofs.vy=-32768-YMin;
+		Ofs.vx=-XMin;
+		Ofs.vy=-YMin;
+*/
+		Ofs.vx=-0;
+		Ofs.vy=-0;
+		Ofs.vz=-4*Scale;
+
+// Adjust Vtx`
+		for (i=0; i<ListSize;i++)
+		{
+			sVtx const	&In=InList[i];
+			sVtx		&Out=OutList[i];
+
+			Out.vx=+(In.vx+Ofs.vx);
+			Out.vy=-(In.vy+Ofs.vy);
+			Out.vz=+(In.vz+Ofs.vz);
+//			printf("%i %i\n",In.vx,In.vy);
+
+		}
+/*
+		XMin=XMax=OutList[0].vx;
+		YMin=YMax=OutList[0].vy;
+// Find Min/Max
+		for (i=1; i<ListSize; i++)
+		{
+			if (XMin>OutList[i].vx) XMin=OutList[i].vx;
+			if (XMax<OutList[i].vx) XMax=OutList[i].vx;
+			if (YMin>OutList[i].vy) YMin=OutList[i].vy;
+			if (YMax<OutList[i].vy) YMax=OutList[i].vy;
+		}
+		printf("MinXY %i,%i  %i,%i\n",XMin,YMin,XMax,YMax);
+*/
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayer3d.h

@@ -0,0 +1,28 @@
+/****************/
+/*** Layer 3d ***/
+/****************/
+
+#ifndef	__MKLEVEL_LAYER_3D__HEADER__
+#define	__MKLEVEL_LAYER_3D__HEADER__
+
+#include	"MkLevelLayerTile.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayer3d : public CMkLevelLayerTile
+{
+public:
+		CMkLevelLayer3d(sExpLayerHdr *LayerHdr) : CMkLevelLayerTile(LayerHdr){};
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+protected:
+		void	ProcessVtxList(vector<sVtx> const &In,vector<sVtx> &Out);
+
+//		CFaceStore					TriList;
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerActor.cpp

@@ -0,0 +1,95 @@
+/*******************/
+/*** Layer Actor ***/
+/*******************/
+
+#include	<Davelib.h>
+#include	<List2d.h>
+
+#include	"..\MkLevel.h"
+#include	"MkLevelLayerActor.h"
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerActor::PreProcess(CMkLevel *Core)
+{
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerActor::Process(CMkLevel *Core)
+{
+int		i,ListSize;
+bool	NotFound;
+
+// Extract Player Start		
+GString	Player=Core->GetConfigStr("MISC","PlayerActor");
+		NotFound=true;
+		ListSize=ThingList.size();
+		for (i=0; i<ListSize && NotFound; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			if (ThisThing.Name==Player)
+			{
+				Core->SetStart(ThisThing.XY[0].x,ThisThing.XY[0].y);
+				NotFound=false;
+				ThingList.erase(i);
+			}
+		}
+		if (NotFound)
+		{
+			GObject::Error(ERR_FATAL,"No Start Point defined");
+		}
+
+		ProcessList();
+		printf("%i actors\n",ThingList.size());
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerActor::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+int			ThisPos=ftell(File);
+sThingHdr	Hdr;
+int			i,ListSize=ThingList.size();
+		
+		Hdr.Count=ListSize;
+		fwrite(&Hdr,sizeof(sThingHdr),1,File);
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			int					p,PointCount=ThisThing.XY.size();
+			sThingActor			OutThing;
+
+			OutThing.Type=ThisThing.Type;
+			OutThing.Health=ThisThing.Data.Health;
+			OutThing.AttackStrength=ThisThing.Data.AttackStrength;
+			OutThing.Speed=ThisThing.Data.Speed;
+			OutThing.TurnRate=ThisThing.Data.TurnRate;
+			OutThing.Flags=ThisThing.Data.CollisionFlag;
+			OutThing.PointCount=PointCount;
+			fwrite(&OutThing,sizeof(sThingActor),1,File);
+
+			for (p=0;p<PointCount;p++)
+			{
+				sThingPoint	Pnt;
+				Pnt.X=ThisThing.XY[p].x;
+				Pnt.Y=ThisThing.XY[p].y;
+				fwrite(&Pnt,sizeof(sThingPoint),1,File);
+			}
+		}
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerActor.h

@@ -0,0 +1,25 @@
+/*******************/
+/*** Layer Actor ***/
+/*******************/
+
+#ifndef	__MKLEVEL_LAYER_ACTOR_HEADER__
+#define	__MKLEVEL_LAYER_ACTOR_HEADER__
+
+#include	"MkLevelLayerThing.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayerActor : public CMkLevelLayerThing
+{
+public:
+		CMkLevelLayerActor(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
+const	char	*GetTypeName()		{return("ACTOR");}
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerCollision.cpp

@@ -0,0 +1,95 @@
+/***********************/
+/*** Layer Collision ***/
+/***********************/
+
+#include	<DaveLib.h>
+#include	<List2d.h>
+
+#include	"MkLevelLayer.h"
+#include	"MkLevelLayerCollision.h"
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+CMkLevelLayerCollision::CMkLevelLayerCollision(sExpLayerHdr *LayerHdr)
+{
+		Type=LayerHdr->Type;
+		SubType=LayerHdr->SubType;
+		Width=LayerHdr->Width;
+		Height=LayerHdr->Height;
+
+sExpColTile	*MapPtr=(sExpColTile*)((int)LayerHdr+sizeof(sExpLayerHdr));
+
+		Map.SetSize(Width,Height);
+		
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				Map.Set(X,Y,*MapPtr++);
+			}
+		}
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerCollision::PreProcess(CMkLevel *Core)
+{
+		//printf("PreProcess Collision Layer\n");
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerCollision::Process(CMkLevel *Core)
+{
+		//printf("Process Collision Layer\n");
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerCollision::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+sLayerHdr	Hdr;
+int			ThisPos=ftell(File);
+int			Width=Map.GetWidth();
+int			Height=Map.GetHeight();
+
+		Hdr.Type=Type;
+		Hdr.SubType=SubType;
+		Hdr.Width=Width;
+		Hdr.Height=Height;
+		fwrite(&Hdr,sizeof(sLayerHdr),1,File);
+
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sExpColTile	&ThisElem=Map.Get(X,Y);	
+				u8		OutElem;
+
+				OutElem=ThisElem.Flags<<COLLISION_TYPE_FLAG_SHIFT;
+				OutElem|=ThisElem.Tile;
+
+				if (ThisElem.Tile>(u16)COLLISION_MASK)
+				{
+					printf("COLLISION OVERFLOW %s: %i,%i=(%i,%i)!!\n",MapName,X,Y,ThisElem.Tile,ThisElem.Flags);
+				}
+				
+				fwrite(&OutElem,sizeof(u8),1,File);
+			}
+		}
+		PadFile(File);
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerCollision.h

@@ -0,0 +1,27 @@
+/***********************/
+/*** Layer Collision ***/
+/***********************/
+
+#ifndef	__MKLEVEL_LAYER_COLLISION_HEADER__
+#define	__MKLEVEL_LAYER_COLLISION_HEADER__
+
+#include	"MkLevelLayer.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayerCollision: public CMkLevelLayer
+{
+public:
+		CMkLevelLayerCollision(sExpLayerHdr *LayerHdr);
+
+virtual	void	PreProcess(CMkLevel *Core);
+virtual	void	Process(CMkLevel *Core);
+virtual	int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+protected:
+
+		CList2d<sExpColTile>	Map;
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerFX.cpp

@@ -0,0 +1,65 @@
+/****************/
+/*** Layer FX ***/
+/****************/
+
+#include	<Davelib.h>
+#include	<List2d.h>
+
+#include	"..\MkLevel.h"
+#include	"MkLevelLayerFX.h"
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerFX::PreProcess(CMkLevel *Core)
+{
+		//printf("Pre-Process FX Layer ()\n");
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerFX::Process(CMkLevel *Core)
+{
+		ProcessList();
+		printf("%i FX\n",ThingList.size());
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerFX::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+int			ThisPos=ftell(File);
+sThingHdr	Hdr;
+int			i,ListSize=ThingList.size();
+		
+		Hdr.Count=ListSize;
+		fwrite(&Hdr,sizeof(sThingHdr),1,File);
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			sThingFX			OutThing;
+
+			OutThing.Type=ThisThing.Type;
+			OutThing.Speed=ThisThing.Data.Speed;
+			OutThing.Pos.X=ThisThing.XY[0].x;
+			OutThing.Pos.Y=ThisThing.XY[0].y;
+			OutThing.Size.X=ThisThing.Data.Width;
+			OutThing.Size.Y=ThisThing.Data.Height;
+			fwrite(&OutThing,sizeof(sThingFX),1,File);
+
+		}
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerFX.h

@@ -0,0 +1,25 @@
+/****************/
+/*** Layer FX ***/
+/***************/
+
+#ifndef	__MKLEVEL_LAYER_FX_HEADER__
+#define	__MKLEVEL_LAYER_FX_HEADER__
+
+#include	"MkLevelLayerThing.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayerFX : public CMkLevelLayerThing
+{
+public:
+		CMkLevelLayerFX(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
+		const	char	*GetTypeName()		{return("FX");}
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerItem.cpp

@@ -0,0 +1,59 @@
+/******************/
+/*** Layer Item ***/
+/******************/
+
+#include	<Davelib.h>
+#include	<List2d.h>
+
+//#include	"MkLevel.h"
+#include	"MkLevelLayerItem.h"
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerItem::PreProcess(CMkLevel *Core)
+{
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerItem::Process(CMkLevel *Core)
+{
+		ProcessList();
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerItem::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+int			ThisPos=ftell(File);
+sThingHdr	Hdr;
+int			i,ListSize=ThingList.size();
+		
+		Hdr.Count=ListSize;
+		fwrite(&Hdr,sizeof(sThingHdr),1,File);
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			sThingItem			OutThing;
+
+			OutThing.Type=ThisThing.Type;
+			OutThing.Pos.X=ThisThing.XY[0].x;
+			OutThing.Pos.Y=ThisThing.XY[0].y;
+			fwrite(&OutThing,sizeof(sThingItem),1,File);
+		}
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerItem.h

@@ -0,0 +1,25 @@
+/******************/
+/*** Layer Item ***/
+/******************/
+
+#ifndef	__MKLEVEL_LAYER_ITEM_HEADER__
+#define	__MKLEVEL_LAYER_ITEM_HEADER__
+
+#include	"MkLevelLayerThing.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayerItem : public CMkLevelLayerThing
+{
+public:
+		CMkLevelLayerItem(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
+const	char	*GetTypeName()		{return("ITEM");}
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerPlatform.cpp

@@ -0,0 +1,71 @@
+/**********************/
+/*** Layer Platform ***/
+/**********************/
+
+#include	<Davelib.h>
+#include	<List2d.h>
+
+//#include	"MkLevel.h"
+#include	"MkLevelLayerPlatform.h"
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerPlatform::PreProcess(CMkLevel *Core)
+{
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerPlatform::Process(CMkLevel *Core)
+{
+		ProcessList();
+		printf("%i Platforms\n",ThingList.size());
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerPlatform::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+int			ThisPos=ftell(File);
+sThingHdr	Hdr;
+int			i,ListSize=ThingList.size();
+		
+		Hdr.Count=ListSize;
+		fwrite(&Hdr,sizeof(sThingHdr),1,File);
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			int					p,PointCount=ThisThing.XY.size();
+			sThingPlatform			OutThing;
+
+			OutThing.Type=ThisThing.Type;
+			OutThing.Speed=ThisThing.Data.Speed;
+			OutThing.TurnRate=ThisThing.Data.TurnRate;
+			OutThing.Flags=ThisThing.Data.CollisionFlag;
+			OutThing.PointCount=PointCount;
+			fwrite(&OutThing,sizeof(sThingPlatform),1,File);
+
+			for (p=0;p<PointCount;p++)
+			{
+				sThingPoint	Pnt;
+				Pnt.X=ThisThing.XY[p].x;
+				Pnt.Y=ThisThing.XY[p].y;
+				fwrite(&Pnt,sizeof(sThingPoint),1,File);
+			}
+		}
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerPlatform.h

@@ -0,0 +1,25 @@
+/**********************/
+/*** Layer Platform ***/
+/**********************/
+
+#ifndef	__MKLEVEL_LAYER_PLATFORM_HEADER__
+#define	__MKLEVEL_LAYER_PLATFORM_HEADER__
+
+#include	"MkLevelLayerThing.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayerPlatform : public CMkLevelLayerThing
+{
+public:
+		CMkLevelLayerPlatform(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
+const	char	*GetTypeName()		{return("PLATFORM");}
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerShade.cpp

@@ -0,0 +1,162 @@
+/*******************/
+/*** Layer Shade ***/
+/*******************/
+
+#include	<DaveLib.h>
+#include	<List2d.h>
+
+#include	"MkLevelLayer.h"
+#include	"MkLevelLayerShade.h"
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+CMkLevelLayerShade::CMkLevelLayerShade(sExpLayerHdr *LayerHdr)
+{
+int		*iPtr;
+u8		*Ptr=(u8*)LayerHdr;
+u8		*RGB;
+
+		Type=LayerHdr->Type;
+		SubType=LayerHdr->SubType;
+		Width=LayerHdr->Width;
+		Height=LayerHdr->Height;
+
+		iPtr=(int*)(Ptr+sizeof(sExpLayerHdr));
+
+		Count=*iPtr++;
+		List.resize(LAYER_SHADE_RGB_MAX);
+		for (int i=0; i<LAYER_SHADE_RGB_MAX; i++)
+		{
+			List[i].Pos=*iPtr++;
+			RGB=(u8*)(iPtr);
+			List[i].RGB[0]=RGB[0];
+			List[i].RGB[1]=RGB[1];
+			List[i].RGB[2]=RGB[2];
+			iPtr+=4/sizeof(int);
+		}
+
+		Trans[0]=*iPtr++;
+		Flags[0]=*iPtr++;
+		Trans[1]=*iPtr++;
+		Flags[1]=*iPtr++;
+
+// Load back gfx
+char	*c=(char*)iPtr;
+		BackGfx[0]=c;  
+		c+=strlen(c)+1;
+		BackGfx[1]=c;  
+
+}
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+// Build unique tiles, including pre-genned flips, and replace tile idx with new one
+void	CMkLevelLayerShade::PreProcess(CMkLevel *Core)
+{
+GString	Path=Core->GetConfigStr("MISC","BackGfxDir");
+
+	for (int i=0; i<2; i++)
+	{
+		if (!BackGfx[i].Empty())
+		{
+			TexID[i]=AddBackGfx(Core,Path+BackGfx[i]+".Bmp");
+		}
+		else
+		{
+			TexID[i]=-1;
+		}
+	}
+}
+
+/*****************************************************************************/
+int		CMkLevelLayerShade::AddBackGfx(CMkLevel *Core,const char *Filename)
+{
+sBackGfxList	NewGfx;
+CTexGrab		&TexGrab=Core->GetTexGrab();
+
+			NewGfx.Name=Filename;
+			NewGfx.TexID=-1;
+
+int			Idx=BackGfxList.Add(NewGfx);
+
+			if (BackGfxList[Idx].TexID==-1)
+			{
+				TexGrab.ZeroColZero(true);
+				BackGfxList[Idx].TexID=TexGrab.AddFile(BackGfxList[Idx].Name);
+				TexGrab.ZeroColZero(false);
+			}
+			
+			return(BackGfxList[Idx].TexID);
+
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerShade::Process(CMkLevel *Core)
+{
+CTexGrab	&TexGrab=Core->GetTexGrab();
+
+		//printf("Process Shade Layer\n");
+		for (int i=0; i<2; i++)
+		{
+			sLayerShadeGfx	&ThisGfx=Data.BackGfx[i];
+			if (TexID[i]==-1)
+			{
+				ThisGfx.TPage=0;
+			}
+			else
+			{
+				sTexOutInfo	&ThisTex=TexGrab.GetTexInfo()[TexID[i]];
+				ThisGfx.TPage=ThisTex.Tpage;
+				ThisGfx.Clut=ThisTex.Clut;
+				ThisGfx.U=ThisTex.u;
+				ThisGfx.V=ThisTex.v;
+				ThisGfx.W=ThisTex.w;
+				ThisGfx.H=ThisTex.h;
+				ThisGfx.TPage|=Trans[i]<<5;
+				ThisGfx.Flags=Flags[i];
+			}
+
+		}
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerShade::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+sLayerHdr		Hdr;
+int				ThisPos=ftell(File);
+
+		Hdr.Type=Type;
+		Hdr.SubType=SubType;
+		Hdr.Width=Width;
+		Hdr.Height=Height;
+		fwrite(&Hdr,sizeof(sLayerHdr),1,File);
+
+		Data.Count=Count;
+		for (int i=0; i<Count; i++)
+		{
+			Data.Data[i].Ofs=List[i].Pos;
+			Data.Data[i].RGB[0]=List[i].RGB[0];
+			Data.Data[i].RGB[1]=List[i].RGB[1];
+			Data.Data[i].RGB[2]=List[i].RGB[2];
+		}
+
+		fwrite(&Data,sizeof(sLayerShadeHdr),1,File);
+		PadFile(File);
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerShade.h

@@ -0,0 +1,51 @@
+/*******************/
+/*** Layer Shade ***/
+/*******************/
+
+#ifndef	__MKLEVEL_LAYER_SHADE_HEADER__
+#define	__MKLEVEL_LAYER_SHADE_HEADER__
+
+#include	"MkLevelLayer.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+struct	SMkLayerShadeRGB
+{
+		int	Pos;
+		u8	RGB[3];
+};
+
+/*****************************************************************************/
+struct  sBackGfxList
+{
+		GString		Name;
+		int			TexID;
+
+bool	operator ==(sBackGfxList const &v1)		{return(Name==v1.Name);}
+};
+
+/*****************************************************************************/
+class	CMkLevelLayerShade : public CMkLevelLayer
+{
+public:
+		CMkLevelLayerShade(sExpLayerHdr *LayerHdr);
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+		int		AddBackGfx(CMkLevel *Core,const char *Filename);
+
+protected:
+			int		Count;
+			vector<SMkLayerShadeRGB>	List;
+			GString						BackGfx[2];
+			int							Flags[2];
+			int							Trans[2];
+
+			CList<sBackGfxList>			BackGfxList;
+			int							TexID[2];
+			sLayerShadeHdr				Data;
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerThing.cpp

@@ -0,0 +1,87 @@
+/*******************/
+/*** Layer Thing ***/
+/*******************/
+
+#include	<DaveLib.h>
+//#include	<List2d.h>
+
+#include	"..\MkLevel.h"
+#include	"MkLevelLayer.h"
+#include	"MkLevelLayerThing.h"
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+CMkLevelLayerThing::CMkLevelLayerThing(sExpLayerHdr *LayerHdr)
+{
+u8		*Ptr=(u8*)LayerHdr;
+
+		Type=LayerHdr->Type;
+		SubType=LayerHdr->SubType;
+		Width=LayerHdr->Width;
+		Height=LayerHdr->Height;
+
+int		*iPtr=(int*)(Ptr+sizeof(sExpLayerHdr));
+
+int		i,ListSize=*iPtr++;
+		ThingList.resize(ListSize);
+		Ptr=(u8*)iPtr;
+		for (i=0; i<ListSize; i++)
+		{
+			Ptr=LoadThing(ThingList[i],Ptr);
+		}
+		LoadThingNames((char*)Ptr);
+
+}
+
+/*****************************************************************************/
+u8		*CMkLevelLayerThing::LoadThing(sMkLevelLayerThing &ThisThing,u8 *Ptr)
+{
+int		i,ListSize;
+
+sLayerThingData	*DPtr=(sLayerThingData*)Ptr;
+
+		ThisThing.Data=*DPtr++;
+int		*iPtr=(int*)DPtr;
+
+		ListSize=ThisThing.Data.WaypointCount;
+		ThisThing.XY.resize(ListSize);
+		for (i=0; i<ListSize; i++)
+		{
+			ThisThing.XY[i].x=*iPtr++;
+			ThisThing.XY[i].y=*iPtr++;
+		}
+		
+		return((u8*)iPtr);
+}
+
+/*****************************************************************************/
+void	CMkLevelLayerThing::LoadThingNames(char *Ptr)
+{
+int		i,ListSize=ThingList.size();
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+
+			ThisThing.Name=Ptr;
+			Ptr+=strlen(Ptr)+1;
+		}
+
+}
+
+/*****************************************************************************/
+void	CMkLevelLayerThing::ProcessList()
+{
+/*
+int		i,ListSize=ThingList.size();
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			bool	Found=CMkLevel::Config.GetInt(GetTypeName(),ThisThing.Name,ThisThing.Type);
+			if (!Found)
+				GObject::Error(ERR_FATAL,"%s not found in list\n",ThisThing.Name);
+		}
+*/
+}

Utils/MkLevel/Layers/MkLevelLayerThing.h

@@ -0,0 +1,46 @@
+/*******************/
+/*** Layer Thing ***/
+/*******************/
+
+#ifndef	__MKLEVEL_LAYER_THING_HEADER__
+#define	__MKLEVEL_LAYER_THING_HEADER__
+
+#include	"MkLevelLayer.h"
+
+struct	sPoint
+{
+	int	x;
+	int	y;
+inline	operator=(sPoint const &Src)	{x=Src.x;y=Src.y;}
+};
+
+struct	sMkLevelLayerThing 
+{
+	GString					Name;
+	int						Type;
+	vector<sPoint>			XY;
+	sLayerThingData			Data;
+};
+
+/*****************************************************************************/
+class	CMkLevelLayerThing : public CMkLevelLayer
+{
+public:
+		CMkLevelLayerThing(sExpLayerHdr *LayerHdr);
+virtual	const char	*GetTypeName()=0;
+
+virtual	void	PreProcess(CMkLevel *Core)=0;
+virtual	void	Process(CMkLevel *Core)=0;
+virtual	int		Write(FILE *File,const char *LayerName,const char *MapName)=0;
+
+protected:
+		u8		*LoadThing(sMkLevelLayerThing &ThisThing,u8 *Ptr);
+		void	LoadThingNames(char *Ptr);
+		void	ProcessList();
+
+		CList<sMkLevelLayerThing>	ThingList;
+		
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerTile.cpp

@@ -0,0 +1,112 @@
+/******************/
+/*** Layer Tile ***/
+/******************/
+
+#include	<DaveLib.h>
+#include	<List2d.h>
+
+#include	"MkLevelLayer.h"
+#include	"MkLevelLayerTile.h"
+
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+CMkLevelLayerTile::CMkLevelLayerTile(sExpLayerHdr *LayerHdr)
+{
+		Type=LayerHdr->Type;
+		SubType=LayerHdr->SubType;
+		Width=LayerHdr->Width;
+		Height=LayerHdr->Height;
+
+sExpLayerTile	*MapPtr=(sExpLayerTile *)((int)LayerHdr+sizeof(sExpLayerHdr));
+
+		InMap.SetSize(Width,Height);
+		
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sExpLayerTile	ThisTile;
+				
+				ThisTile.Tile=MapPtr->Tile;
+				ThisTile.Flags=MapPtr->Flags;
+				InMap.Set(X,Y,ThisTile);
+				MapPtr++;
+			}
+		}
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerTile::PreProcess(CMkLevel *Core)
+{
+int		Width=InMap.GetWidth();
+int		Height=InMap.GetHeight();
+
+		OutMap.SetSize(Width,Height);
+
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sExpLayerTile	&InElem=InMap.Get(X,Y);
+				sMkLevelElem	&OutElem=OutMap.Get(X,Y);
+				
+				OutElem.Elem=0;
+				if (InElem.Tile)
+				{ // Dont process blanks
+					OutElem.Elem=Core->AddTile2d(InElem);
+				}
+			}
+		}
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerTile::Process(CMkLevel *Core)
+{
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerTile::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+sLayerHdr	Hdr;
+int			ThisPos=ftell(File);
+int			Width=OutMap.GetWidth();
+int			Height=OutMap.GetHeight();
+
+		Hdr.Type=Type;
+		Hdr.SubType=SubType;
+		Hdr.Width=Width;
+		Hdr.Height=Height;
+		fwrite(&Hdr,sizeof(sLayerHdr),1,File);
+
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				sMkLevelElem	&ThisElem=OutMap.Get(X,Y);	
+				
+				ASSERT(Hdr.SubType!=LAYER_SUBTYPE_ACTION);
+				fwrite(&ThisElem.Elem,sizeof(u16),1,File);
+
+			}
+		}
+		PadFile(File);
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerTile.h

@@ -0,0 +1,34 @@
+/******************/
+/*** Layer Tile ***/
+/******************/
+
+#ifndef	__MKLEVEL_LAYER_TILE_HEADER__
+#define	__MKLEVEL_LAYER_TILE_HEADER__
+
+#include	"MkLevelLayer.h"
+#include	<List2d.h>
+
+struct	sMkLevelElem
+{
+	u16				Elem;
+	int				TexID;
+};
+
+/*****************************************************************************/
+class	CMkLevelLayerTile : public CMkLevelLayer
+{
+public:
+		CMkLevelLayerTile(sExpLayerHdr *LayerHdr);
+
+virtual	void	PreProcess(CMkLevel *Core);
+virtual	void	Process(CMkLevel *Core);
+virtual	int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+protected:
+		CList2d<sExpLayerTile>		InMap;
+		CList2d<sMkLevelElem>		OutMap;
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Layers/MkLevelLayerTrigger.cpp

@@ -0,0 +1,63 @@
+/*********************/
+/*** Layer Trigger ***/
+/*********************/
+
+#include	<Davelib.h>
+#include	<List2d.h>
+
+//#include	"MkLevel.h"
+#include	"MkLevelLayerTrigger.h"
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Pre-Process *************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerTrigger::PreProcess(CMkLevel *Core)
+{
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Process *****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+void	CMkLevelLayerTrigger::Process(CMkLevel *Core)
+{
+		ProcessList();
+		printf("%i Trigger\n",ThingList.size());
+
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/** Write ********************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int		CMkLevelLayerTrigger::Write(FILE *File,const char *LayerName,const char *MapName)
+{
+int			ThisPos=ftell(File);
+sThingHdr	Hdr;
+int			i,ListSize=ThingList.size();
+		
+		Hdr.Count=ListSize;
+		fwrite(&Hdr,sizeof(sThingHdr),1,File);
+
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelLayerThing	&ThisThing=ThingList[i];
+			sThingTrigger		OutThing;
+
+			OutThing.Type=ThisThing.Type;
+			OutThing.Pos.X=ThisThing.XY[0].x;
+			OutThing.Pos.Y=ThisThing.XY[0].y;
+			OutThing.Width=ThisThing.Data.Width;
+			OutThing.Height=ThisThing.Data.Height;
+			fwrite(&OutThing,sizeof(sThingTrigger),1,File);
+		}
+
+		return(ThisPos);
+}
+
+/*****************************************************************************/

Utils/MkLevel/Layers/MkLevelLayerTrigger.h

@@ -0,0 +1,25 @@
+/*********************/
+/*** Layer Trigger ***/
+/*********************/
+
+#ifndef	__MKLEVEL_LAYER_TRIGGER_HEADER__
+#define	__MKLEVEL_LAYER_TRIGGER_HEADER__
+
+#include	"MkLevelLayerThing.h"
+#include	<List2d.h>
+
+/*****************************************************************************/
+class	CMkLevelLayerTrigger : public CMkLevelLayerThing
+{
+public:
+		CMkLevelLayerTrigger(sExpLayerHdr *LayerHdr) : CMkLevelLayerThing(LayerHdr){};
+const	char	*GetTypeName()		{return("TRIGGER");}
+
+		void	PreProcess(CMkLevel *Core);
+		void	Process(CMkLevel *Core);
+		int		Write(FILE *File,const char *LayerName,const char *MapName);
+
+};
+
+/*****************************************************************************/
+#endif

Utils/MkLevel/Main.cpp

@@ -0,0 +1,107 @@
+/*******************************/
+/*** SpongeBob Level Creator ***/
+/*******************************/
+
+#include	"stdio.h"
+#include	<misc.hpp>
+#include	<vector>
+#include	<DaveLib.h>
+#include	<GFName.hpp>
+
+#include	"MkLevel.h"
+
+//***************************************************************************
+CMkLevel	Level;
+int			TPBase=-1,TPW=-1,TPH=-1;
+
+//***************************************************************************
+char * CycleCommands(char *String,int Num)
+{
+char	Text[256],*TextPtr;
+int		Count;
+
+		if (String[0]=='-' || String[0]=='/')
+		{
+			GString		TpStr;
+			TpStr= String;
+			TpStr.Upper();
+			switch (String[1])
+			{// Switches 
+				case 'o':
+					OutStr = CheckFileString(String);
+					break;
+				case 'd':
+					DebugOn =true;
+					break;
+				case 's':
+					TpStr= CheckFileString(String);
+					Scale=atof(TpStr);
+					break;
+				case 't':
+					TpStr= CheckFileString(String);
+					TextPtr=Text;
+					strcpy(TextPtr,TpStr);
+					Count=ZeroAndCountCommas(TextPtr);
+					if (Count!=2)
+							GObject::Error(ERR_FATAL,"Problem with option %s\n",String);
+					TPBase=atol(TextPtr);
+					TextPtr+=strlen(TextPtr)+1;
+					TPW=atol(TextPtr);
+					TextPtr+=strlen(TextPtr)+1;
+					TPH=atol(TextPtr);
+					break;
+				case 'q':
+					StripLength=4;
+					break;
+				default:
+					GObject::Error(ERR_FATAL,"Unknown switch %s",String);
+					break;
+			}
+		}
+		else
+		{
+			GString	UpperName(String);
+			UpperName.Upper();
+			MyFiles.AddFile(UpperName);
+		}
+
+		return(String);
+}
+
+//***************************************************************************
+
+void Usage(char *ErrStr)
+{
+	printf("\nMkLevel: by Dave\n");
+	printf("Usage: MkLevel <file> [ <file>.. ] [ switches.. ]\n");
+	printf("Switches:\n");
+	printf("   -o:[FILE]       Set output File (AND Dir)\n");
+	printf("   -s:nn           Set Scaling value\n");
+	printf("   -t:p,w,h        Set TPage No,Width,Height\n");
+//	printf("   -c:             Set Chapter Name\n");
+//	printf("   -l:             Set Level Name\n");
+	printf("   -d:             Enable Debug output\n");
+//	printf("   -q:             Enable Quadding\n");
+	GObject::Error(ERR_FATAL,ErrStr);
+}
+
+//***************************************************************************
+
+int		main(int argc, char *argv[])
+{
+		CommandLine(argc,argv,CycleCommands);
+
+std::vector<GString> const &Files = MyFiles.GetFileInfoVector();
+
+		if (Files.size()==0)	Usage("No Levels specified\n");
+		if (Files.size()>1)		Usage("Too many Levels specified\n");
+
+		Level.Init(Files[0],OutStr,TPBase,TPW,TPH);
+		Level.Load();
+		Level.Process();
+		Level.Write();
+		return 0;
+}
+
+
+

Utils/MkLevel/MkLevel.cpp

@@ -0,0 +1,801 @@
+/*********************/
+/*** MkLevel Class ***/
+/*********************/
+
+#include	"stdio.h"
+#include	<misc.hpp>
+#include	<GFName.hpp>
+#include	<conio.h>
+#include	<iostream.h>
+#include	<vector>
+#include	<DaveLib.h>
+
+#include	"MkLevel.h"
+#include	"Layers\MkLevelLayer.h"
+
+#include	"Layers\MkLevelLayerTile.h"
+#include	"Layers\MkLevelLayer3d.h"
+#include	"Layers\MkLevelLayerShade.h"
+#include	"Layers\MkLevelLayerCollision.h"
+
+#include	"Layers\MkLevelLayerActor.h"
+#include	"Layers\MkLevelLayerItem.h"
+#include	"Layers\MkLevelLayerPlatform.h"
+#include	"Layers\MkLevelLayerFX.h"
+#include	"Layers\MkLevelLayerTrigger.h"
+
+//***************************************************************************
+GString			ConfigFilename="MkLevel";
+sExpLayerTile	BlankTile={-1,-1};
+
+//***************************************************************************
+CMkLevel::CMkLevel()
+{
+		memset(&LvlHdr,0,sizeof(sLvlHdr));
+		Tile2dList.Add(BlankTile);
+}
+
+//***************************************************************************
+CMkLevel::~CMkLevel()
+{
+}
+
+//***************************************************************************
+void	CMkLevel::Init(const char *Filename,const char *OutDir,int TPBase,int TPW,int TPH)
+{
+// Setup filenames and paths
+GFName		Path=Filename;
+
+			InFilename=Filename;
+			LevelName=Path.File();
+			Path.File("");
+			Path.Ext("");
+			InPath=Path.FullName();
+			OutPath=OutDir; OutPath.Append('\\');
+			OutName=OutPath+LevelName;
+
+// Load ini file
+#ifdef	_DEBUG
+		ConfigFilename="\\spongebob\\tools\\data\\bin\\mklevel.ini";
+#endif
+		Config.LoadAndImport(ConfigFilename);
+
+// Setup Texgrab
+		if (TPBase==-1 || TPW==-1 || TPH==-1) 
+			GObject::Error(ERR_FATAL,"TPage not set\n");
+
+		TexGrab.SetTPage(TPBase,TPW,TPH);
+		TexGrab.SetOutFile(GString(OutName+".Tex"));
+		TexGrab.SetDebug(DebugOn);
+		TexGrab.SetDebugOut(GString(OutName+".Lbm"));
+		TexGrab.NoSort();
+		TexGrab.AnimatedHeadersOnly(true);
+		TexGrab.DontOutputBoxes(true);
+	//!!!	TexGrab.AllowRotate(true);
+		TexGrab.AllowRotate(false);
+	//!!!	TexGrab.ShrinkToFit(true);
+		TexGrab.ShrinkToFit(false);
+
+// Setup TriList
+		OutTriList.SetTexGrab(TexGrab);
+
+// Set up other stuph
+
+		FlatFace[0].vtx[0].x=+0.5f; FlatFace[0].vtx[0].y=+1.0f;	FlatFace[0].vtx[0].z=-4.0f;
+		FlatFace[0].vtx[1].x=-0.5f; FlatFace[0].vtx[1].y= 0.0f;	FlatFace[0].vtx[1].z=-4.0f;
+		FlatFace[0].vtx[2].x=+0.5f; FlatFace[0].vtx[2].y= 0.0f;	FlatFace[0].vtx[2].z=-4.0f;
+		FlatFace[0].uvs[0].u=1;		FlatFace[0].uvs[0].v=1;
+		FlatFace[0].uvs[1].u=0;		FlatFace[0].uvs[1].v=0;
+		FlatFace[0].uvs[2].u=1;		FlatFace[0].uvs[2].v=0;
+
+		FlatFace[1].vtx[0].x=-0.5f; FlatFace[1].vtx[0].y= 0.0f;	FlatFace[1].vtx[0].z=-4.0f;
+		FlatFace[1].vtx[1].x=+0.5f; FlatFace[1].vtx[1].y=+1.0f;	FlatFace[1].vtx[1].z=-4.0f;
+		FlatFace[1].vtx[2].x=-0.5f; FlatFace[1].vtx[2].y=+1.0f;	FlatFace[1].vtx[2].z=-4.0f;
+		FlatFace[1].uvs[0].u=0;		FlatFace[1].uvs[0].v=0;
+		FlatFace[1].uvs[1].u=1;		FlatFace[1].uvs[1].v=1;
+		FlatFace[1].uvs[2].u=0;		FlatFace[1].uvs[2].v=1;
+
+}
+
+//***************************************************************************
+//*** Load ******************************************************************
+//***************************************************************************
+void	CMkLevel::Load()
+{
+FILE		*File;
+sExpFileHdr	*FileHdr;
+int			Size;
+
+			printf("Load %s\n",LevelName);
+
+			File=fopen(InFilename,"rb");
+			if (!File)
+				GObject::Error(ERR_FATAL,"%s Not found\n",InFilename);
+// Calc File Size
+			fseek(File,0,SEEK_END);
+			Size=ftell(File);
+			fseek(File,0,SEEK_SET);
+			FileHdr=(sExpFileHdr*)malloc(Size);
+// Load It
+			fread(FileHdr,Size,1,File);
+			fclose(File);
+
+			LoadTiles(FileHdr);
+			LoadLayers(FileHdr);
+
+			free(FileHdr);
+}
+
+//***************************************************************************
+void		CMkLevel::LoadStrList(CList<GString> &List,char *TexPtr,int Count)
+{
+char	FullName[256];
+GString	FilePath;
+
+		for (int i=0; i<Count; i++)
+		{
+			if (!strcmp(TexPtr,"BLANK")) GObject::Error(ERR_FATAL,"Old Format. Please Re-export\n");
+			GFName::makeabsolute(InPath,TexPtr,FullName);
+			List.push_back(GString(FullName));
+			TexPtr+=strlen(TexPtr)+1;
+		}
+}
+
+//***************************************************************************
+void	CMkLevel::LoadTiles(sExpFileHdr *FileHdr)
+{
+u8		*ByteHdr=(u8*)FileHdr;
+int		i,ListSize;
+int		RGBSize;
+
+		TileW=FileHdr->TileW;
+		TileH=FileHdr->TileH;
+		RGBSize=TileW*TileH*3;
+
+// Load SetNames
+		LoadStrList(InSetNameList,(char*) &ByteHdr[FileHdr->SetNameOfs],FileHdr->SetNameCount);
+// Load TexNames
+		LoadStrList(InTexNameList,(char*) &ByteHdr[FileHdr->TexNameOfs],FileHdr->TexNameCount);
+
+// Load Tiles
+u8		*TilePtr=(u8*) &ByteHdr[FileHdr->TileOfs];
+
+		InTileList.resize(FileHdr->TileCount);
+		for (i=0; i<FileHdr->TileCount; i++)
+		{
+			sExpTile	*ThisTilePtr=(sExpTile*)TilePtr;
+			sExpTile	&InTile=InTileList[i];
+			
+			InTile=*ThisTilePtr;
+			InTile.RGB=(u8*)malloc(RGBSize);
+			memcpy(InTile.RGB,TilePtr+sizeof(sExpTile),RGBSize);
+			TilePtr+=RGBSize+sizeof(sExpTile);
+		}
+
+// Load Tris
+sExpTri	*TriPtr=(sExpTri*) &ByteHdr[FileHdr->TriOfs];
+		InTriList.resize(FileHdr->TriCount);
+		for (i=0; i<FileHdr->TriCount; i++)
+		{
+			InTriList[i]=TriPtr[i];
+		}
+
+// Load 2d bitmaps
+		ListSize=InSetNameList.size();
+		BmpList.resize(ListSize);
+		for (i=0; i<ListSize; i++)
+		{
+			GString	Ext=GFName(InSetNameList[i]).Ext();
+			if (Ext=="BMP")
+			{
+			BmpList[i].LoadBMP(InSetNameList[i]);
+			}
+		}
+
+}
+
+//***************************************************************************
+void	CMkLevel::LoadLayers(sExpFileHdr *FileHdr)
+{
+u8		*ByteHdr=(u8*)FileHdr;
+
+		for (int i=0; i<FileHdr->LayerCount; i++)
+		{
+			sExpLayerHdr *LayerHdr=(sExpLayerHdr *)&ByteHdr[FileHdr->LayerOfs[i]];
+
+			switch(LayerHdr->Type)
+			{
+			case LAYER_TYPE_TILE:
+				switch (LayerHdr->SubType)
+				{
+				case LAYER_SUBTYPE_ACTION:
+					LayerList.push_back(new CMkLevelLayer3d(LayerHdr));
+					break;
+				case LAYER_SUBTYPE_MID:
+					LayerList.push_back(new CMkLevelLayerTile(LayerHdr));
+					break;
+				case LAYER_SUBTYPE_BACK:
+				default:
+					break;
+				}
+				break;
+			case LAYER_TYPE_COLLISION:
+				LayerList.push_back(new CMkLevelLayerCollision(LayerHdr));
+				break;
+			case LAYER_TYPE_SHADE:
+				LayerList.push_back(new CMkLevelLayerShade(LayerHdr));
+				break;
+			case LAYER_TYPE_ACTOR:
+				LayerList.push_back(new CMkLevelLayerActor(LayerHdr));
+				break;
+			case LAYER_TYPE_ITEM:
+				LayerList.push_back(new CMkLevelLayerItem(LayerHdr));
+				break;
+			case LAYER_TYPE_PLATFORM:
+				LayerList.push_back(new CMkLevelLayerPlatform(LayerHdr));
+				break;
+			case LAYER_TYPE_TRIGGER:
+				LayerList.push_back(new CMkLevelLayerTrigger(LayerHdr));
+				break;
+			case LAYER_TYPE_FX:
+				LayerList.push_back(new CMkLevelLayerFX(LayerHdr));
+				break;
+			default:
+				GObject::Error(ERR_FATAL,"Unknown Layer Type\n");
+			}
+		}
+}
+
+//***************************************************************************
+//*** Process ***************************************************************
+//***************************************************************************
+void	CMkLevel::Process()
+{
+		printf("PreProcess Layers\n");
+		PreProcessLayers();
+		printf("Process Tilebank\n");
+		ProcessTileBanks();
+		printf("Process Layers\n");
+		ProcessLayers();
+		OutTriList.Process();
+}
+
+//***************************************************************************
+void	CMkLevel::PreProcessLayers()
+{
+int		LayerCount=LayerList.size();
+
+		for (int i=0; i<LayerCount; i++)
+		{
+			LayerList[i]->PreProcess(this);
+		}
+}
+
+//***************************************************************************
+void	CMkLevel::ProcessLayers()
+{
+int		LayerCount=LayerList.size();
+
+		for (int i=0; i<LayerCount; i++)
+		{
+			LayerList[i]->Process(this);
+		}
+}
+
+//***************************************************************************
+void	CMkLevel::ProcessTileBanks()
+{
+		PreProcessTileBank2d();
+		PreProcessTileBank3d();
+		TexGrab.Process();
+		ProcessTileBank2d();
+		ProcessTileBank3d();
+}
+
+//***************************************************************************
+void	CMkLevel::PreProcessTileBank2d()
+{
+int		i,ListSize=Tile2dList.size();
+
+		Tile2dList[0].Tile=-1;
+// Extract Tex data from list
+		for (i=1; i<ListSize; i++)
+		{ // Skip blank
+			sExpLayerTile &ThisTile=Tile2dList[i];
+			ThisTile.Tile=Create2dTex(ThisTile);
+		}
+}
+
+//***************************************************************************
+void	CMkLevel::ProcessTileBank2d()
+{
+int		i,ListSize=Tile2dList.size();
+vector<sTexOutInfo>	&TexInfo=TexGrab.GetTexInfo();
+
+		OutTile2dList.resize(ListSize);
+		for (i=1; i<ListSize; i++)
+		{ // Skip blank
+			sExpLayerTile	&InTile=Tile2dList[i];
+			sTile2d			&OutTile=OutTile2dList[i];
+
+			SetUpTileUV(OutTile,TexInfo[InTile.Tile]);
+		}
+
+}
+
+
+//***************************************************************************
+void	CMkLevel::PreProcessTileBank3d()
+{
+int		i,ListSize=Tile3dList.size();
+
+		for (i=0; i<ListSize; i++)
+		{
+			sExpLayerTile &ThisTile=Tile3dList[i];
+			ThisTile.Tile=Create3dTile(ThisTile);
+		}
+}
+
+//***************************************************************************
+void	CMkLevel::ProcessTileBank3d()
+{
+int		i,ListSize=Tile3dList.size();
+
+		for (i=0; i<ListSize; i++)
+		{
+
+		}
+}
+
+//***************************************************************************
+void	CMkLevel::SetUpTileUV(sTile2d &Out, sTexOutInfo &Info)
+{
+int		W = Info.w-1;
+int		H = Info.h-1;
+float	Inx0, Iny0;
+u8		Outx0, Outy0;
+
+// Allow for upside textures now :oP
+		Inx0=0;
+		Iny0=1-0;
+
+		if (Info.Rotated)
+		{
+			GObject::Error(ERR_FATAL,"Rotated Texure, cant cope!\n");
+		} 
+
+		Outx0 = Info.u +		round(Inx0 * W);
+		Outy0 = (Info.v + H) -  round(Iny0 * H);
+
+		Out.u0=Outx0; Out.v0=Outy0;
+		Out.TPage=Info.Tpage;
+		Out.Clut=Info.Clut;
+}
+
+//***************************************************************************
+//***************************************************************************
+//***************************************************************************
+CMkLevelLayer	*CMkLevel::FindLayer(int Type,int SubType)
+{
+int		ListSize=LayerList.size();
+
+		for (int i=0; i<ListSize; i++)
+		{
+			if (LayerList[i]->IsType(Type,SubType)) return(LayerList[i]);
+		}
+		return(0);
+}
+
+//***************************************************************************
+int		CMkLevel::Create3dTile(sExpLayerTile &InTile)
+{
+sExpTile		&SrcTile=InTileList[InTile.Tile];
+CFace			F;
+int				i,ListSize;
+CList<sExpTri>	SortList;
+CList<float>	ZPosList;
+
+			if (SrcTile.TriCount)
+			{
+				for (i=0; i<SrcTile.TriCount; i++)
+				{
+					int		ListPos;
+					sExpTri	ThisTri=InTriList[SrcTile.TriStart+i];
+					float	ThisZPos;
+					
+
+					ThisZPos=ThisTri.vtx[0].z;
+					if (ThisZPos>ThisTri.vtx[1].z) ThisZPos=ThisTri.vtx[1].z;
+					if (ThisZPos>ThisTri.vtx[2].z) ThisZPos=ThisTri.vtx[2].z;
+					
+					ListSize=SortList.size();
+					for (ListPos=0; ListPos<ListSize; ListPos++)
+					{
+						if (ZPosList[ListPos]<ThisZPos) break;
+					}
+					// Flip 3d tiles
+					bool	SwapPnt=false;
+
+					if (InTile.Flags & PC_TILE_FLAG_MIRROR_X)	
+					{
+						ThisTri.vtx[0].x=-ThisTri.vtx[0].x;
+						ThisTri.vtx[1].x=-ThisTri.vtx[1].x;
+						ThisTri.vtx[2].x=-ThisTri.vtx[2].x;
+						SwapPnt^=1;
+					}
+
+					if (InTile.Flags & PC_TILE_FLAG_MIRROR_Y)	
+					{
+						ThisTri.vtx[0].y	=1.0-ThisTri.vtx[0].y;
+						ThisTri.vtx[1].y	=1.0-ThisTri.vtx[1].y;
+						ThisTri.vtx[2].y	=1.0-ThisTri.vtx[2].y;
+						SwapPnt^=1;
+					}
+					if (SwapPnt)
+					{
+						Vector3	TmpV=ThisTri.vtx[0];
+						ThisTri.vtx[0]=ThisTri.vtx[1];
+						ThisTri.vtx[1]=TmpV;
+						float	TmpUVu=ThisTri.uv[0][0];
+						float	TmpUVv=ThisTri.uv[0][1];
+						ThisTri.uv[0][0]=ThisTri.uv[1][0];
+						ThisTri.uv[0][1]=ThisTri.uv[1][1];
+						ThisTri.uv[1][0]=TmpUVu;
+						ThisTri.uv[1][1]=TmpUVv;
+					}
+					SortList.insert(ListPos,ThisTri);
+					ZPosList.insert(ListPos,ThisZPos);
+				}
+
+// Add sorted list to main list
+
+				for (i=0; i<SrcTile.TriCount; i++)
+				{
+					sExpTri &ThisTri=SortList[i];
+					CFace	F;
+					F.TexName=InTexNameList[ThisTri.TexID];
+					F.Mat=-1;
+
+					for (int p=0; p<3; p++)
+					{
+						F.vtx[p]=ThisTri.vtx[p];
+						F.uvs[p].u=ThisTri.uv[p][0];
+						F.uvs[p].v=ThisTri.uv[p][1];
+					}
+					OutTriList.AddFace(F,true);
+				}
+			}
+			else
+			{ // create flat tile
+				int		TexID=Create2dTex(InTile);
+				for (int i=0; i<2; i++)
+				{
+					FlatFace[i].Mat=TexID;
+					OutTriList.AddFace(FlatFace[i],true);
+				}
+			}
+
+		return(0);
+}
+
+
+//***************************************************************************
+int		CMkLevel::Create2dTex(sExpLayerTile &InTile)
+{
+sExpTile	&SrcTile=InTileList[InTile.Tile];
+int			Idx;
+sMkLevelTex	InTex;
+
+//		InTex.Set=UsedSetNameList.Add(InSetNameList[SrcTile.Set]);
+		InTex.Set=SrcTile.Set;//UsedSetNameList.Add(InSetNameList[SrcTile.Set]);
+		InTex.Flags=InTile.Flags;
+		InTex.XOfs=SrcTile.XOfs;
+		InTex.YOfs=SrcTile.YOfs;
+		InTex.RGB=SrcTile.RGB;
+
+		Idx=Tex2dList.Find(InTex);
+		if (Idx!=-1) return(Idx);
+
+// Try and find RGB data match
+		Idx=FindRGBMatch(InTex);
+		if (Idx!=-1) return(Idx);
+
+// Must be new, add it
+		BuildTileTex(InTex);
+		Tex2dList.push_back(InTex);
+		return(InTex.TexID);
+}
+
+//***************************************************************************
+int		CMkLevel::BuildTileTex(sMkLevelTex &InTex)
+{
+		ASSERT(InTex.Set>=0 && InTex.Set<InSetNameList.size())
+Frame			&InFrame=BmpList[InTex.Set];
+Frame			ThisFrame;
+Rect			ThisRect;
+GString			Name=GFName(InSetNameList[InTex.Set]).File();
+GString			TexName;
+int				BmpW=InFrame.GetWidth();
+int				BmpH=InFrame.GetHeight();
+
+				TexGrab.ShrinkToFit(false);
+				TexGrab.AllowRotate(false);
+
+				if (InTex.XOfs*16>BmpW) 
+				{
+					printf("AARGH!!! %s(%i) wants X=%i,tile is only %i Wide\n",Name,InTex.Set,InTex.XOfs*16,BmpW);
+					InTex.XOfs=0;
+				}
+				if (InTex.YOfs*16>BmpH) 
+				{
+					printf("AARGH!!! %s(%i) wants Y=%i,tile is only %i High\n",Name,InTex.Set,InTex.YOfs*16,BmpH);
+					InTex.YOfs=0;
+				}
+
+				MakeTexName(InTex,TexName);
+
+				ThisRect.X=InTex.XOfs*16;
+				ThisRect.Y=InTex.YOfs*16;
+				ThisRect.W=16;
+				ThisRect.H=16;
+
+				ThisFrame.Grab(InFrame,ThisRect);
+
+				if (InTex.Flags& PC_TILE_FLAG_MIRROR_X)		ThisFrame.FlipX();
+				if (InTex.Flags & PC_TILE_FLAG_MIRROR_Y)	ThisFrame.FlipY();
+				
+				InTex.TexID=TexGrab.AddMemFrame(TexName,ThisFrame);
+
+#ifdef	_DEBUG
+				if (0)
+				{
+					if (!ThisFrame.IsBlank())
+					{
+					char	DbgName[256];
+					sprintf(DbgName,"/x/%s.lbm",TexName);
+					ThisFrame.SaveLbm(DbgName);
+					}
+				}
+#endif
+			return(InTex.TexID);
+}
+
+//***************************************************************************
+void	CMkLevel::MakeTexName(sMkLevelTex &InTex,GString &OutStr)
+{
+char			NewName[256];
+GString			Name=GFName(InSetNameList[InTex.Set]).File();
+			
+		sprintf(NewName,"%s_%02d_%02d_%01d_",Name,InTex.XOfs,InTex.YOfs,InTex.Flags&PC_TILE_FLAG_MIRROR_XY);
+		OutStr=NewName;
+}
+
+//***************************************************************************
+int		CMkLevel::FindRGBMatch(sMkLevelTex &ThisTex)
+{
+int		i,ListSize=Tex2dList.size();
+int		Size=TileW*TileH;
+u8		*RGBPtr=ThisTex.RGB;
+
+// Create Checksum for this tile
+		ThisTex.RChk=0;
+		ThisTex.GChk=0;
+		ThisTex.BChk=0;
+		for (i=0; i<Size; i++)
+		{
+			ThisTex.RChk+=*RGBPtr++;
+			ThisTex.GChk+=*RGBPtr++;
+			ThisTex.BChk+=*RGBPtr++;
+		}
+// Check all others for match
+		for (i=0; i<ListSize; i++)
+		{
+			sMkLevelTex &ChkTex=Tex2dList[i];
+			if (ChkTex.RGB)
+			{
+// Checksum first
+				if (ThisTex.RChk==ChkTex.RChk && ThisTex.GChk==ChkTex.GChk && ThisTex.BChk==ChkTex.BChk) 
+				{
+					if (IsRGBSame(ThisTex,ChkTex)) return(i);
+				}
+			}
+		}
+		return(-1);
+}
+
+//***************************************************************************
+bool	CMkLevel::IsRGBSame(const sMkLevelTex &Tex0,const sMkLevelTex &Tex1)
+{
+int		W=TileW;
+int		H=TileH;
+int		XOfs0,YOfs0;
+int		XOfs1,YOfs1;
+u8		*RGB0=Tex0.RGB;
+u8		*RGB1=Tex1.RGB;
+
+		XOfs0=YOfs0=0;
+		XOfs1=YOfs1=0;
+
+		if (Tex0.Flags & PC_TILE_FLAG_MIRROR_X) XOfs0=W-1;
+		if (Tex0.Flags & PC_TILE_FLAG_MIRROR_Y) YOfs0=H-1;
+		if (Tex1.Flags & PC_TILE_FLAG_MIRROR_X) XOfs1=W-1;
+		if (Tex1.Flags & PC_TILE_FLAG_MIRROR_Y) YOfs1=H-1;
+
+		for (int Y=0; Y<H; Y++)
+		{
+			for (int X=0; X<W; X++)
+			{
+				int	X0=abs(XOfs0-X);
+				int	Y0=abs(YOfs0-Y);
+				int	X1=abs(XOfs1-X);
+				int	Y1=abs(YOfs1-Y);
+				int	Idx0=X0+(Y0*W);
+				int	Idx1=X1+(Y1*W);
+
+				if (RGB0[Idx0+0]!=RGB1[Idx1+0]) return(false);
+				if (RGB0[Idx0+1]!=RGB1[Idx1+1]) return(false);
+				if (RGB0[Idx0+2]!=RGB1[Idx1+2]) return(false);
+			}
+		}
+		return(true);
+}
+
+//***************************************************************************
+//*** Write *****************************************************************
+//***************************************************************************
+void	CMkLevel::Write()
+{
+		WriteLevel();
+		WriteTileBank();
+}
+
+//***************************************************************************
+void	CMkLevel::WriteTileBank()
+{
+GString	OutFilename=OutName+".Tbk";
+int		i,ListSize;
+		File=fopen(OutFilename,"wb");
+
+		fwrite(&TileBankHdr,1,sizeof(sTileBankHdr),File);
+
+// 2d Tilebank
+		TileBankHdr.TileBank2d=(sTile2d*)ftell(File);
+		ListSize=OutTile2dList.size();
+		for (i=0; i<ListSize; i++)
+		{
+			sTile2d	&OutTile=OutTile2dList[i];
+			fwrite(&OutTile,1,sizeof(sTile2d),File);
+		}
+// 3d Tilebank
+		TileBankHdr.TileBank3d=(sTile3d*)ftell(File);
+		ListSize=OutTile3dList.size();
+		for (i=0; i<ListSize; i++)
+		{
+			sTile3d	&OutTile=OutTile3dList[i];
+			fwrite(&OutTile,1,sizeof(sTile3d),File);
+		}
+// TriList
+		TileBankHdr.TriList=(sTri*)WriteTriList();
+		
+// QuadList
+
+// VtxList
+		TileBankHdr.VtxList=(sVtx*)ftell(File);
+		OutTriList.WriteVtxList(File);
+
+// rewrite header
+		fseek(File,0,SEEK_SET);
+		fwrite(&TileBankHdr,1,sizeof(sTileBankHdr),File);
+
+		fclose(File);
+}
+
+
+//***************************************************************************
+int		CMkLevel::WriteTriList()
+{
+vector<sTri>	&TriList=OutTriList.GetOutTriList();
+vector<sVtx> const	&VtxList=OutTriList.GetVtxList();
+int				ThisPos=ftell(File);
+int				i,ListSize=TriList.size();
+int				MaxOT=0;		
+		for (i=0;i<ListSize;i++)
+		{
+			sTri	&T=TriList[i];
+			int		Z[3];
+			int		OtOfs=0;
+// Calc OtOfs
+			Z[0]=abs(VtxList[T.P0].vz);
+			Z[1]=abs(VtxList[T.P1].vz);
+			Z[2]=abs(VtxList[T.P2].vz);
+			
+			for (int p=0; p<3; p++)
+			{
+				if (OtOfs<Z[p]) OtOfs=Z[p];
+			}
+			if (MaxOT<OtOfs) MaxOT=OtOfs;
+			if (OtOfs>63) OtOfs=63;
+// Write It			
+			fwrite(&T,1,sizeof(sTri),File);
+		}
+		printf("MAXOT = %i\n",MaxOT);
+
+		return(ThisPos);
+
+}
+
+//***************************************************************************
+//*** Write *****************************************************************
+//***************************************************************************
+void	CMkLevel::WriteLevel()
+{
+GString	OutFilename=OutName+".Lvl";
+
+		File=fopen(OutFilename,"wb");
+
+		fwrite(&LvlHdr,1,sizeof(sLvlHdr),File);
+
+		WriteLayers();
+
+// rewrite header
+		fseek(File,0,SEEK_SET);
+		fwrite(&LvlHdr,1,sizeof(sLvlHdr),File);
+
+		fclose(File);
+}
+
+//***************************************************************************
+void	CMkLevel::WriteLayers()
+{
+// Back (Shade)
+		LvlHdr.BackLayer=WriteLayer(LAYER_TYPE_SHADE,LAYER_SUBTYPE_BACK,0);//"Shade");
+// Mid
+		LvlHdr.MidLayer=WriteLayer(LAYER_TYPE_TILE,LAYER_SUBTYPE_MID,"Mid");
+// Action
+		LvlHdr.ActionLayer=WriteLayer(LAYER_TYPE_TILE,LAYER_SUBTYPE_ACTION,"Action");
+// Fore
+//		LvlHdr.ForeLayer=WriteLayer(LAYER_TYPE_TILE,LAYER_SUBTYPE_FORE,"Fore");
+// Collision
+		LvlHdr.CollisionLayer=WriteLayer(LAYER_TYPE_COLLISION,LAYER_SUBTYPE_NONE,"Collision");
+
+// Things
+		LvlHdr.ActorList=WriteThings(LAYER_TYPE_ACTOR,"Actor List");
+		LvlHdr.ItemList=WriteThings(LAYER_TYPE_ITEM,"Item List");
+		LvlHdr.PlatformList=WriteThings(LAYER_TYPE_PLATFORM,"Platform List");
+		LvlHdr.TriggerList=WriteThings(LAYER_TYPE_TRIGGER,"FX List");
+		LvlHdr.FXList=WriteThings(LAYER_TYPE_FX,"FX List");
+}
+
+//***************************************************************************
+int		CMkLevel::WriteLayer(int Type,int SubType,const char *LayerName)
+{
+CMkLevelLayer	*ThisLayer=FindLayer(Type,SubType);
+int		Ofs;
+
+		if (!ThisLayer)
+		{
+			if (LayerName) GObject::Error(ERR_WARNING,"No %s Layer Found in %s!!\n",LayerName,LevelName);
+			return(0);
+		}
+		Ofs=ThisLayer->Write(File,LayerName,LevelName);
+
+		PadFile(File);
+		return(Ofs);
+}
+
+//***************************************************************************
+int		CMkLevel::WriteThings(int Type,const char *LayerName)
+{
+CMkLevelLayer	*ThisLayer=FindLayer(Type,LAYER_SUBTYPE_NONE);
+int		Ofs;
+
+		if (!ThisLayer)
+		{
+			GFName		Name=InFilename;
+			if (LayerName) GObject::Error(ERR_WARNING,"No %s Layer Found in %s!!\n",LayerName,Name.File());
+			return(0);
+		}
+		Ofs=ThisLayer->Write(File,LayerName,LevelName);
+		PadFile(File);
+		return(Ofs);
+}

Utils/MkLevel/MkLevel.dsp

@@ -0,0 +1,190 @@
+# Microsoft Developer Studio Project File - Name="MkLevel" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=MkLevel - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "MkLevel.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "MkLevel.mak" CFG="MkLevel - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "MkLevel - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "MkLevel - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""$/Utils/MkLevel", JTGAAAAA"
+# PROP Scc_LocalPath "."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "MkLevel - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /G6 /MD /W3 /GX /O2 /I "..\libs\glib" /I "..\libs\maths" /I "..\libs\davelib" /I "..\libs\ginlib" /I "..\libs\texgrab" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib glib.lib ginlib.lib texgrab.lib maths.lib /nologo /subsystem:console /machine:I386 /out:"..\..\tools\data\bin\MkLevel.exe" /libpath:"..\libs\psxlib\release" /libpath:"..\libs\ginlib\release" /libpath:"..\libs\glib\release" /libpath:"..\libs\davelib\release" /libpath:"..\libs\texgrab\release" /libpath:"..\libs\maths\release"
+
+!ELSEIF  "$(CFG)" == "MkLevel - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "..\libs\glib" /I "..\libs\maths" /I "..\libs\davelib" /I "..\libs\ginlib" /I "..\libs\psxlib" /I "..\libs\texgrab" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Fr /YX /FD /GZ /c
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib glib.lib ginlib.lib texgrab.lib maths.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\libs\ginlib\debug" /libpath:"..\libs\glib\debug" /libpath:"..\libs\davelib\debug" /libpath:"..\libs\texgrab\debug" /libpath:"..\libs\maths\debug"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "MkLevel - Win32 Release"
+# Name "MkLevel - Win32 Debug"
+# Begin Group "Layers"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayer3d.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayer3d.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerActor.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerActor.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerCollision.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerCollision.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerFX.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerFX.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerItem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerPlatform.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerPlatform.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerShade.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerShade.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerThing.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerThing.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerTile.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerTile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerTrigger.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Layers\MkLevelLayerTrigger.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MkLevel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MkLevel.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\tools\Data\bin\MkLevel.ini
+# End Source File
+# End Target
+# End Project

Utils/MkLevel/MkLevel.h

@@ -0,0 +1,128 @@
+/*************************/
+/*** Base Level Holder ***/
+/*************************/
+
+#ifndef	__MKLEVEL_HEADER__
+#define	__MKLEVEL_HEADER__
+
+#include	<vector>
+#include	<List.h>
+#include	<FaceStore.h>
+#include	"IniClass.h"
+
+// Map Editor header files
+#include	"..\mapedit\LayerDef.h"
+#include	"..\mapedit\ExportHdr.h"
+
+using namespace std;
+
+//***************************************************************************
+struct	sMkLevelTex
+{
+		int		Set;
+		int		XOfs,YOfs;
+		u8		*RGB;
+		int		Flags;
+		int		RChk,GChk,BChk;
+		int		TexID;
+
+bool	operator ==(sMkLevelTex const &v1)
+		{
+		if (Set!=v1.Set) return(false);
+		if (XOfs!=v1.XOfs) return(false);
+		if (YOfs!=v1.YOfs) return(false);
+		if (Flags!=v1.Flags) return(false);
+		return(true);
+		}
+};
+
+//***************************************************************************
+class	CMkLevelLayer;
+class	CMkLevel
+{
+public:
+		CMkLevel();
+		~CMkLevel();
+
+		void			Init(const char *InFilename,const char *OutPath,int TPBase,int TPW,int TPH);
+
+		void			Load();
+
+		void			Process();
+		int				AddTile3d(sExpLayerTile &Tile)	{return(Tile3dList.Add(Tile));}
+		int				AddTile2d(sExpLayerTile &Tile)	{return(Tile2dList.Add(Tile));}
+
+		void			Write();
+
+		int				Create2dTex(sExpLayerTile &ThisTile);
+		int				Create3dTile(sExpLayerTile &ThisTile);
+		int				FindRGBMatch(sMkLevelTex &ThisTex);
+		bool			IsRGBSame(const sMkLevelTex &Tile0,const sMkLevelTex &Tile1);
+		void			MakeTexName(sMkLevelTex &InTex,GString &OutStr);
+		int				BuildTileTex(sMkLevelTex &InTex);
+
+		char			*GetConfigStr(const char *Grp,const char *Key)	{return(Config.GetStr(Grp,Key));}
+		CTexGrab		&GetTexGrab()									{return(TexGrab);}
+
+		void			SetStart(int X,int Y)				{LvlHdr.PlayerStartX=X; LvlHdr.PlayerStartY=Y;}
+protected:	
+		CMkLevelLayer	*FindLayer(int Type,int SubType);
+		void			LoadStrList(CList<GString> &List,char *TexPtr,int Count);
+
+		void			LoadTiles(sExpFileHdr *FileHdr);
+		void			LoadLayers(sExpFileHdr *FileHdr);
+		void			LoadLayer(sExpLayerHdr *LayerHdr);
+
+		void			PreProcessLayers();
+		void			ProcessTileBanks();
+		void			PreProcessTileBank2d();
+		void			ProcessTileBank2d();
+		void			PreProcessTileBank3d();
+		void			ProcessTileBank3d();
+		void			ProcessLayers();
+		void            SetUpTileUV(sTile2d &Out, sTexOutInfo &Info);
+
+		void			WriteLevel();
+		void			WriteLayers();
+		int				WriteLayer(int Type,int SubType,const char *LayerName);
+		int				WriteThings(int Type,const char *LayerName);
+		int				WriteTriList();
+		int				WriteQuadList();
+		void			WriteTileBank();
+
+		void            BuildTiles();
+
+		FILE					*File;
+		GString					InFilename,InPath,LevelName;
+		GString					OutPath,OutName;
+
+		int						TileW,TileH;
+		CIni					Config;
+
+		CList<sExpTri>			InTriList;
+		CList<sExpTile>			InTileList;
+		CList<GString>			InSetNameList;
+		CList<GString>			InTexNameList;
+		CList<GString>			UsedSetNameList;
+		CList<GString>			UsedTexNameList;
+
+		CFaceStore				OutTriList;
+		CList<sTile2d>			OutTile2dList;
+		CList<sTile3d>			OutTile3dList;
+
+		CList<sExpLayerTile>	Tile2dList;
+		CList<sExpLayerTile>	Tile3dList;
+		CList<sMkLevelTex>		Tex2dList;
+		CTexGrab				TexGrab;
+		CList<Frame>			BmpList;
+
+		vector<CMkLevelLayer*>	LayerList;
+
+		sLvlHdr					LvlHdr;
+		sTileBankHdr			TileBankHdr;
+		CFace					FlatFace[2];
+
+};
+
+//***************************************************************************
+#endif