Utils/MapEdit/Core.cpp

@@ -27,7 +27,6 @@
 #include	"Export.h"
 #include	"LayerList.h"
 
-const Vector3	DefaultCamPos(0.0f,0.0f,0.9f);
 
 /*****************************************************************************/
 /*****************************************************************************/
@@ -36,12 +35,12 @@ CCore::CCore()
 {
 		CurrentMousePos=CPoint(0,0);
 		MapCam=DefaultCamPos;
-		TileCam=DefaultCamPos;
 		SpareFlag=false;
 		GridFlag=true;
 		Is3dFlag=true;
 		CurrentView=NULL;
 		CursorPos.x=CursorPos.y=0;
+		CurrentLayer=0;
 		
 }
 
@@ -86,10 +85,10 @@ void	CCore::Load(CFile *File)
 {
 int		Version,i;
 BOOL	F;
-
+Vector3	DuffVector;
 		File->Read(&Version,sizeof(int));
 		if (Version>100000) Version=1;	// Check fix for changing version to int from float
-
+#ifndef _DEBUG
 		if (Version<FileVersion)
 		{
 			CString mexstr;
@@ -97,13 +96,17 @@ BOOL	F;
 			AfxMessageBox(mexstr,MB_OK | MB_ICONEXCLAMATION);
 
 		}
+#endif
 
 		TRACE1("Load Version %i\n",Version);
 
 		File->Read(&MapCam,sizeof(Vector3));
-		File->Read(&MapCamOfs,sizeof(Vector3));
+		if (Version<FileVersion)
-		File->Read(&TileCam,sizeof(Vector3));
+		{
-		File->Read(&TileCamOfs,sizeof(Vector3));
+			File->Read(&MapCamOfs,sizeof(Vector3));
+			File->Read(&DuffVector,sizeof(Vector3));
+			File->Read(&DuffVector,sizeof(Vector3));
+		}
 	
 		File->Read(&F,sizeof(BOOL));  SpareFlag=F!=0;
 		File->Read(&F,sizeof(BOOL));  GridFlag=F!=0;
@@ -161,9 +164,6 @@ BOOL	F;
 		File->Write(&FileVersion,sizeof(int));
 
 		File->Write(&MapCam,sizeof(Vector3));
-		File->Write(&MapCamOfs,sizeof(Vector3));
-		File->Write(&TileCam,sizeof(Vector3));
-		File->Write(&TileCamOfs,sizeof(Vector3));
 
 		F=SpareFlag;	File->Write(&F,sizeof(BOOL));
 		F=GridFlag;		File->Write(&F,sizeof(BOOL));
@@ -182,7 +182,12 @@ int		LayerCount=Layer.size();
 			Layer[i]->Save(File);
 		}
 	GetTileBank()->Save(File);
-
+/*
+CString	a=File->GetFilePath();
+char	Txt[256];
+		sprintf(Txt,"%s",a);
+	Export(Txt);
+*/
 }
 
 /*****************************************************************************/
@@ -209,14 +214,14 @@ Vector3	&ThisCam=GetCam();
 			UpdateAll();
 			return;
 		}
-		if (GetTileBank()->NeedLoad()) GetTileBank()->LoadTileSets(this);
+//		if (GetTileBank()->NeedLoad()) GetTileBank()->LoadAllSets(this);
 
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen
 
-		if (CurrentLayer!=Layer[ActiveLayer] || CurrentLayer->IsUnique())
+		if (IsSubView() || CurrentLayer->IsUnique())
 		{
 			CurrentLayer->Render(this,ThisCam,Is3dFlag);
-			CurrentLayer->RenderGrid(this,ThisCam,true);
+			if (GridFlag) CurrentLayer->RenderGrid(this,ThisCam,true);
 			CurrentLayer->FindCursorPos(this,GetCam(),CurrentMousePos);
 		}
 		else
@@ -398,7 +403,7 @@ bool	RedrawFlag=false;
 			break;
 
 		}
-/*		if (RedrawFlag) */RedrawView();
+		RedrawView();
 
 }
 
@@ -454,14 +459,12 @@ int		LastLayer=ActiveLayer;
 		}
 		else
 		{
-			bool	IsCol=Layer[NewLayer]->GetType()==LAYER_TYPE_COLLISION;
-			GetTileBank()->SetCollision(IsCol);
 			ActiveLayer=NewLayer;
 		}
 
 		if (LastLayer!=ActiveLayer || Force)
 		{
-			if (LastLayer<=LayerCount) CurrentLayer->GUIKill(this);
+			if (LastLayer<=LayerCount) Layer[LastLayer]->GUIKill(this);
 			CurrentLayer=Layer[ActiveLayer];
 			CurrentLayer->GUIInit(this);
 			GUIUpdate();
@@ -487,7 +490,6 @@ int			Idx=ListSize;
 		Layer.insert(Layer.begin() + Idx,NewLayer);
 		
 		if (NewLayer->GetType()==LAYER_TYPE_TILE && NewLayer->GetSubType()==LAYER_SUBTYPE_ACTION) ActionLayer=(CLayerTile*)NewLayer;
-		NewLayer->InitSubView(this);
 		return(Idx);
 }
 
@@ -511,6 +513,7 @@ int		Idx;
 				ASSERT(!"AddLayer - Invalid Layer Type");
 				break;
 		}
+		if (ActionLayer) Layer[Idx]->InitSubView(this);
 		return(Idx);
 }
 
@@ -549,23 +552,25 @@ int		Idx=AddLayer(CLayer::InfoTable[NewLayerId].Type,CLayer::InfoTable[NewLayerI
 }
 
 /*****************************************************************************/
-void		CCore::DeleteLayer(int CurrentLayer)
+void		CCore::DeleteLayer(int ThisLayer)
 {
-		if (Layer[CurrentLayer]->CanDelete())
+
+		if (Layer[ThisLayer]->CanDelete())
 		{
-			Layer[CurrentLayer]->GUIKill(this);
+//			Layer[CurrentLayer]->GUIKill(this);
-			delete Layer[CurrentLayer];
+			SetLayer(ThisLayer-1,true);
-			Layer.erase(Layer.begin() + CurrentLayer);
+			delete Layer[ThisLayer];
-			SetLayer(CurrentLayer-1,true);
+			Layer.erase(Layer.begin() + ThisLayer);
-			TRACE1("Deleted Layer %i\n",CurrentLayer);
+			TRACE1("Deleted Layer %i\n",ThisLayer);
 		}
 		else
 		{
-			TRACE1("Cant Delete Layer %i\n",CurrentLayer);
+			TRACE1("Cant Delete Layer %i\n",ThisLayer);
 		}
 }
 
 /*****************************************************************************/
+/*
 CLayer		*CCore::FindSubView(int Type)
 {
 int			i,ListSize=Layer.size();
@@ -580,7 +585,7 @@ int			i,ListSize=Layer.size();
 			}
 		return(0);
 }
-
+*/
 /*****************************************************************************/
 /*** Grid ********************************************************************/
 /*****************************************************************************/
@@ -604,7 +609,7 @@ CLayer	*LastLayer=CurrentLayer;
 			LastLayer->GUIKill(this);
 			CurrentLayer->GUIInit(this);
 			GUIUpdate();
-			RedrawView();
+			UpdateView();
 		}
 }
 
@@ -613,10 +618,12 @@ CLayer	*LastLayer=CurrentLayer;
 /*****************************************************************************/
 Vector3	&CCore::GetCam()
 {
-//		if (SubViewFlag)
+		if (IsSubView() || CurrentLayer->IsUnique())
-//			return(TileCam);
+		{
-//		else
+			return(CurrentLayer->GetCam());
-			return(MapCam);
+		}
+
+		return(MapCam);
 
 }
 
@@ -719,6 +726,7 @@ void	CCore::RedrawView()
 /*****************************************************************************/
 void	CCore::UpdateView(Vector3 *Ofs)
 {
+		if (!CurrentLayer) return;
 		if (Ofs)
 		{
 			Vector3	&ThisCam=GetCam();
@@ -726,8 +734,11 @@ void	CCore::UpdateView(Vector3 *Ofs)
 			ThisCam.x+=Ofs->x;
 			ThisCam.y+=Ofs->y;
 			ThisCam.z-=Ofs->z;
-			if (ThisCam.x<0) ThisCam.x=0;
+			if (!IsSubView())
-			if (ThisCam.y<0) ThisCam.y=0;
+			{
+				if (ThisCam.x<0) ThisCam.x=0;
+				if (ThisCam.y<0) ThisCam.y=0;
+			}
 			if (ThisCam.z<0.1) ThisCam.z=0.1f;
 		}
 
@@ -779,7 +790,6 @@ Vector3	ThisCam=Cam;
 
 	ThisCam=Cam/DivVal;
 	ThisCam.z=Cam.z;
-
 	return(ThisCam);
 }
 

Utils/MapEdit/Core.h

@@ -19,11 +19,13 @@
 #include	"Layer.h"
 #include	"LayerTile.h"
 
-const	s32		FileVersion=3;
+const	s32		FileVersion=4;
 
 #define	SCREEN_MAP_WIDTH	30
 #define	SCREEN_MAP_HEIGHT	20
 
+const Vector3	DefaultCamPos(0.0f,0.0f,0.9f);
+
 /*****************************************************************************/
 class	CMapEditView;
 
@@ -58,8 +60,8 @@ public:
 // Subview & TileBank
 		CTileBank				*GetTileBank()					{return(ActionLayer->GetTileBank());}
 		void					ToggleSubView();
-		CLayer					*FindSubView(int Type);
+//		CLayer					*FindSubView(int Type);
-
+		bool					IsSubView()						{return(CurrentLayer!=Layer[ActiveLayer]);}
 // GUI 
 		void					UpdateParamBar();
 		void					GUIAdd(CDialog &Dlg,int ID,bool Visible=true,bool Lock=false);
@@ -117,7 +119,7 @@ private:
 		CMapEditView			*CurrentView;
 		CPoint					CurrentMousePos,LastMousePos;
 		CPoint					CursorPos,LastCursorPos;
-		Vector3					MapCam,TileCam;
+		Vector3					MapCam;
 		Vector3					MapCamOfs,TileCamOfs;
 		Vector3					ScaleVector;
 

Utils/MapEdit/Elem.cpp

@@ -1,5 +1,5 @@
 /*********************/
-/*** Tile Stuph ***/
+/*** Elem Stuph ***/
 /*********************/
 
 #include	"stdafx.h"
@@ -11,8 +11,7 @@
 
 #include	"Core.h"
 #include	"TexCache.h"
-//#include	"TileSet.h"
+#include	"Elem.h"
-#include	"Tile.h"
 #include	"GinTex.h"
 #include	"utils.h"
 
@@ -36,26 +35,25 @@ const float	YFlipMtx[]=
 };
 
 /*****************************************************************************/
-/*
+CElem::CElem(int Width,int Height)
-CTile::CTile()
 {
-}
+		ElemWidth=Width;
-*/
+		ElemHeight=Height;
-/*****************************************************************************/
+		UnitWidth=ElemWidth/UnitSize;
-CTile::CTile(int Blank,int _Width,int _Height)
+		UnitHeight=ElemHeight/UnitSize;
-{
+		ElemID=-1;
-		Width=_Width;
+		ElemRGB=(u8*)malloc(ElemWidth*ElemHeight*3);
-		Height=_Height;
+		memset(ElemRGB,0,ElemWidth*ElemHeight*3);
-		PCTexID=-1;
+
-		PCTexRGB=(u8*)malloc(Width*Height*3);
+		Type=ElemType2d;
-		memset(PCTexRGB,0,Width*Height*3);
+		TexXOfs=0;
-		Tex2dID=-1;
+		TexYOfs=0;
-		Type=TileType2d;
+		CreateBlankTileGfx();
 }
 
 /*****************************************************************************/
-// 3d tile (From Gin File)
+// 3d Elem (From Gin File)
-CTile::CTile(CCore *Core,const char *Filename,CScene &ThisScene,int Node)
+CElem::CElem(CCore *Core,const char *Filename,CScene &ThisScene,int Node)
 {
 CNode		&ThisNode=ThisScene.GetNode(Node);
 CTexCache	&TexCache=Core->GetTexCache();
@@ -65,36 +63,50 @@ GFName		Path=Filename;
 			SetPath+=Path.Dir();
 			SetPath.Append('\\');
 
-			Type=TileType3d;
+			Type=ElemType3d;
 			TexXOfs=-1;
 			TexYOfs=-1;
-			Build3dTile(TexCache,ThisScene,Node);
+			Build3dElem(TexCache,ThisScene,Node);
+			Calc3dSize();
 			Ofs.x=+0.5f; Ofs.y=0; Ofs.z=+4.0f;
-			Build3dDrawList(TexCache,DrawList[TileType3d]);
+			Build3dDrawList(TexCache,DrawList[ElemType3d]);
 			Create2dTexture(TexCache,Path.File(),Node);
-			Build2dDrawList(TexCache,DrawList[TileType2d]);
+			Build2dDrawList(TexCache,DrawList[ElemType2d]);
+			if (!ValidFlag)	CreateInvalidTileGfx();
+
 }
 
 /*****************************************************************************/
-// 2d tile (From Bmp File)
+// 2d Elem (From Bmp File)
-CTile::CTile(CCore *Core,const char *Filename,int TexID,int XOfs,int YOfs)
+CElem::CElem(CCore *Core,const char *Filename,int TexID,int XOfs,int YOfs,int Width,int Height)
 {
 CTexCache	&TexCache=Core->GetTexCache();
 GFName		Path=Filename;
 
-			Type=TileType2d;
+			ElemWidth=Width;
+			ElemHeight=Height;
+			UnitWidth=ElemWidth/UnitSize;
+			UnitHeight=ElemHeight/UnitSize;
+
+			Type=ElemType2d;
 			TexXOfs=XOfs;
 			TexYOfs=YOfs;
-
+			Build2dElem(Core,Path.File(),TexID);
-			Build2dTile(Core,Path.File(),TexID);
 			Ofs.Zero();
-			Build3dDrawList(TexCache,DrawList[TileType3d]);
+			Build3dDrawList(TexCache,DrawList[ElemType3d]);
 			Create2dTexture(TexCache,Path.File(),TexID);
-			Build2dDrawList(TexCache,DrawList[TileType2d]);
+			Build2dDrawList(TexCache,DrawList[ElemType2d]);
+			if (!ValidFlag)	CreateInvalidTileGfx();
 }
 
 /*****************************************************************************/
-void	CTile::Build2dTile(CCore *Core,const char *Filename,int TexID)
+void	CElem::CleanUp()
+{
+		free(ElemRGB);
+}
+
+/*****************************************************************************/
+void	CElem::Build2dElem(CCore *Core,const char *Filename,int TexID)
 {
 const Vector3	P0(0.0f,0.0f,0.0f);
 const Vector3	P1(1.0f,0.0f,0.0f);
@@ -111,11 +123,10 @@ sTex		&ThisTex=TexCache.GetTex(TexID);
 
 float		u0,u1,v0,v1;
 		
-			Tex2dID=TexID;
 			u0=(TexXOfs)*ThisTex.dW;
 			u1=u0+ThisTex.dW;
 
-			v0=(((ThisTex.TexHeight/16)-(TexYOfs+1))*ThisTex.dH);
+			v0=(((ThisTex.TexHeight/UnitSize)-(TexYOfs+1))*ThisTex.dH);
 			v1=v0+ThisTex.dH;
 
 			Tri0.Mat=TexID;
@@ -137,7 +148,7 @@ float		u0,u1,v0,v1;
 }
 
 /*****************************************************************************/
-void	CTile::Build3dTile(CTexCache &TexCache,CScene &ThisScene,int Node)
+void	CElem::Build3dElem(CTexCache &TexCache,CScene &ThisScene,int Node)
 {
 CNode						&ThisNode=ThisScene.GetNode(Node);
 int							ChildCount=ThisNode.GetChildCount();
@@ -170,7 +181,7 @@ int			ListSize=TriList.size();
 					ThisName=SetPath+TexList[TexID];
 					TexID=TexCache.ProcessTexture(ThisName,MatList[ThisMat].Flags);
 					}
-// Sort Rest
+// Sort Rest of Tri info
 				for (int p=0; p<3; p++)
 				{
 					Tri.vtx[p]=NodeVtxList[ThisTri.p[p]];
@@ -180,29 +191,58 @@ int			ListSize=TriList.size();
 				}
 			}
 
-		for (int Child=0; Child<ChildCount; Child++) Build3dTile(TexCache,ThisScene,ThisNode.PruneChildList[Child]);
+		for (int Child=0; Child<ChildCount; Child++) Build3dElem(TexCache,ThisScene,ThisNode.PruneChildList[Child]);
 
 }
 
 /*****************************************************************************/
-void	CTile::Build2dDrawList(CTexCache &TexCache,GLint &List)
+void	CElem::Calc3dSize()
+{
+int			ListSize=TriList.size();
+float		XMin=+9999;
+float		XMax=-9999;
+float		YMin=+9999;
+float		YMax=-9999;
+
+		for (int i=0; i<ListSize; i++)
+		{
+			sTriFace		&Tri=TriList[i];
+			for (int p=0; p<3; p++)
+			{
+				if (XMin>Tri.vtx[p].x) XMin=Tri.vtx[p].x;
+				if (XMax<Tri.vtx[p].x) XMax=Tri.vtx[p].x;
+				if (YMin>Tri.vtx[p].y) YMin=Tri.vtx[p].y;
+				if (YMax<Tri.vtx[p].y) YMax=Tri.vtx[p].y;
+			}
+		}
+		UnitWidth=round(XMax-XMin);
+		UnitHeight=round(YMax-YMin);
+		if (UnitWidth<1) UnitWidth=1;
+		if (UnitHeight<1) UnitHeight=1;
+		ElemWidth=UnitWidth*UnitSize;
+		ElemHeight=UnitHeight*UnitSize;
+
+}
+
+/*****************************************************************************/
+void	CElem::Build2dDrawList(CTexCache &TexCache,GLint &List)
 {
 			List=glGenLists(1);
 			glNewList(List,GL_COMPILE);
 
-			glBindTexture(GL_TEXTURE_2D, TexCache.GetTexGLId(PCTexID));
+			glBindTexture(GL_TEXTURE_2D, TexCache.GetTexGLId(ElemID));
 			glBegin (GL_QUADS);
 				glTexCoord2f(0.0f,0.0f);
 				glVertex3f( 0.0f,0.0f,0.0f);
 
 				glTexCoord2f(1.0f,0.0f);
-				glVertex3f( 1.0f,0.0f,0.0f);
+				glVertex3f( UnitWidth,0.0f,0.0f);
 
 				glTexCoord2f(1.0f,1.0f);
-				glVertex3f( 1.0f,1.0f,0.0f);
+				glVertex3f( UnitWidth,UnitHeight,0.0f);
 
 				glTexCoord2f(0.0f,1.0f);
-				glVertex3f( 0.0f,1.0f,0.0f);
+				glVertex3f( 0.0f,UnitHeight,0.0f);
 
 			glEnd();
 			glEndList();
@@ -211,7 +251,7 @@ void	CTile::Build2dDrawList(CTexCache &TexCache,GLint &List)
 
 /*****************************************************************************/
 // Build OpenGL display lists, sorted by material (luckily by gin!!)
-void	CTile::Build3dDrawList(CTexCache &TexCache,GLint &List)
+void	CElem::Build3dDrawList(CTexCache &TexCache,GLint &List)
 {
 int			TriCount=TriList.size();
 int			LastMat=-1,ThisMat;
@@ -247,9 +287,8 @@ int			LastMat=-1,ThisMat;
 }
 
 /*****************************************************************************/
-void	CTile::Render(int Flags,bool Render3d)
+void	CElem::Render(int Flags,bool Render3d)
 {
-		if (!ValidFlag) return;
 		glPushMatrix();
 
 		if (Flags & PC_TILE_FLAG_MIRROR_X)
@@ -279,23 +318,94 @@ int		ColFlags=Flags >> PC_TILE_FLAG_COLLISION_SHIFT;
 		}
 
 		glEnable(GL_TEXTURE_2D);
-		glCallList(DrawList[Render3d]);
+		if (Render3d) 
+		{
+			glEnable(GL_DEPTH_TEST);
+			glCallList(DrawList[ElemType3d]);
+			glDisable(GL_DEPTH_TEST);
+		}
+		else
+		{
+			glCallList(DrawList[ElemType2d]);
+		}
 		glDisable(GL_TEXTURE_2D);
 		glPopMatrix();
 }
 
 /*****************************************************************************/
-void	CTile::Purge()
+void	CElem::Purge()
 {
-		glDeleteLists(DrawList[TileType3d],1);
+		for (int i=0; i<ElemTypeMax; i++)
-		glDeleteLists(DrawList[TileType2d],1);
+			glDeleteLists(DrawList[i],1);
 		TriList.clear();
 }
 
 /*****************************************************************************/
-void	CTile::RenderTile4Texture(sRGBData &RGBData)
+// Only created for the tile browser, should NEVER appear in main view
+void	CElem::CreateBlankTileGfx()
+{
+float	X0=0;
+float	X1=UnitWidth;
+float	Y0=0;
+float	Y1=UnitHeight;
+
+		Purge();
+		for (int i=0; i<ElemTypeMax; i++)
+		{
+			DrawList[i]=glGenLists(1);
+			glNewList(DrawList[i],GL_COMPILE);
+			glBindTexture(GL_TEXTURE_2D, 0);
+			glBegin(GL_LINES); 
+				glColor4f(1,1,1,1);
+		
+				glVertex3f( X0,Y0,0);
+				glVertex3f( X1,Y0,0);
+
+				glVertex3f( X0,Y1,0);
+				glVertex3f( X1,Y1,0);
+
+				glVertex3f( X0,Y0,0);
+				glVertex3f( X0,Y1,0);
+
+				glVertex3f( X1,Y0,0);
+				glVertex3f( X1,Y1,0);
+			glEnd();
+			glEndList();
+	}
+}
+
+/*****************************************************************************/
+void	CElem::CreateInvalidTileGfx()
+{
+float	X0=0;
+float	X1=UnitWidth;
+float	Y0=0;
+float	Y1=UnitHeight;
+
+		Purge();
+		for (int i=0; i<ElemTypeMax; i++)
+		{
+			DrawList[i]=glGenLists(1);
+			glNewList(DrawList[i],GL_COMPILE);
+			glBindTexture(GL_TEXTURE_2D, 0);
+			glBegin(GL_LINES); 
+				glColor4f(1,1,1,1);
+			
+				glVertex3f( X0,Y0,0);
+				glVertex3f( X1,Y1,0);
+
+				glVertex3f( X1,Y0,0);
+				glVertex3f( X0,Y1,0);
+			glEnd();
+			glEndList();
+	}
+}
+
+/*****************************************************************************/
+void	CElem::RenderElem4Texture(sRGBData &RGBData)
 {
 
+		glClearColor(1,0,1,1 );
 		glPushAttrib(GL_VIEWPORT_BIT);
 		glViewport(0,0,RGBData.Width,RGBData.Height);
 
@@ -315,7 +425,7 @@ void	CTile::RenderTile4Texture(sRGBData &RGBData)
 		glColor3f(1,1,1);
 		glEnable(GL_TEXTURE_2D);
 		glEnable(GL_DEPTH_TEST);
-		glCallList(DrawList[TileType3d]);
+		glCallList(DrawList[ElemType3d]);
 		glDisable(GL_DEPTH_TEST);
 		glDisable(GL_TEXTURE_2D);
 
@@ -325,23 +435,24 @@ void	CTile::RenderTile4Texture(sRGBData &RGBData)
 		glPopAttrib();
 
 		glReadPixels(0,0,RGBData.Width,RGBData.Height,GL_RGB, GL_UNSIGNED_BYTE,RGBData.RGB);
+		glClearColor(0,0,0,1 );
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen
 }
 
 /*****************************************************************************/
 // ID used to create unique textures within one set :o)
-void	CTile::Create2dTexture(CTexCache &TexCache,const char *Filename,int ID)
+void	CElem::Create2dTexture(CTexCache &TexCache,const char *Filename,int ID)
 {
 sRGBData	RGBData;
 
-// PC
+		ElemRGB=(u8*)malloc(ElemWidth*ElemHeight*3);
-		glClearColor(1,0,1,1 );
+
-		RGBData.Width=PCTexWidth;
+		RGBData.Width=ElemWidth;
-		RGBData.Height=PCTexHeight;
+		RGBData.Height=ElemHeight;
-		RGBData.RGB=PCTexRGB;
+		RGBData.RGB=ElemRGB;
-		RenderTile4Texture(RGBData);
+		RenderElem4Texture(RGBData);
-		PCTexID=TexCache.ProcessTexture("",0,&RGBData);
+		ElemID=TexCache.ProcessTexture("",0,&RGBData);
 		ValidFlag=CheckHasData(RGBData);
-		glClearColor(0,0,0,1 );
 
 #ifdef _DEBUG
 		if (0)
@@ -351,7 +462,7 @@ char	TexName[256];
 static	asd=0;
 		sprintf(TexName,"_2dPc_%s_%03d",Filename,asd++);
 		sprintf(Filename,"/x/%s.Tga",TexName);
-		SaveTGA(Filename,PCTexWidth,PCTexHeight,PCTexRGB);
+		SaveTGA(Filename,ElemWidth,ElemHeight,ElemRGB);
 		}
 
 #endif
@@ -359,7 +470,7 @@ static	asd=0;
 }
 
 /*****************************************************************************/
-bool	CTile::CheckHasData(sRGBData &RGBData)
+bool	CElem::CheckHasData(sRGBData &RGBData)
 {
 u8		*Src=RGBData.RGB;
 int		Size=RGBData.Width*RGBData.Height;
@@ -376,6 +487,271 @@ int		Size=RGBData.Width*RGBData.Height;
 }
 
 /*****************************************************************************/
+/*****************************************************************************/
+/*** Elem Set ****************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+CElemSet::CElemSet(const char *_Filename,int Idx,int Width,int Height)
+{
+GFName	FName=_Filename;
 
+		Filename=_Filename;
+		Name=FName.File();
+		
+		DefWidth=Width;
+		DefHeight=Height;
+		Loaded=FALSE;
+		SetNumber=Idx;
+}
 
+/*****************************************************************************/
+CElemSet::~CElemSet()
+{
+int	ListSize=ElemList.size();
+
+		for (int i=0; i<ListSize; i++)
+		{
+			ElemList[i].CleanUp();
+		}
+}
+
+/*****************************************************************************/
+void	CElemSet::Load(CCore *Core)
+{
+GFName	FName=Filename;
+GString	Ext=FName.Ext();
+		Ext.Upper();
+
+		if (Ext=="GIN")
+			Load3d(Core);
+		else
+			Load2d(Core);
+		Loaded=TRUE;
+}
+
+/*****************************************************************************/
+void	CElemSet::Load2d(CCore *Core)
+{
+CTexCache	&TexCache=Core->GetTexCache();
+int			TexID=TexCache.ProcessTexture(Filename,0);
+sTex		&ThisTex=TexCache.GetTex(TexID);
+int			Width=ThisTex.TexWidth/DefWidth;
+int			Height=ThisTex.TexHeight/DefHeight;
+
+		ElemList.push_back(CElem(DefWidth,DefHeight));	// Insert Blank		
+		
+		for (int Y=0; Y<Height; Y++)
+		{
+			for (int X=0; X<Width; X++)
+			{
+				ElemList.push_back(CElem(Core,Filename,TexID,X,Y,DefWidth,DefHeight));
+			}
+		}
+		ElemBrowserWidth=Width;
+}
+
+/*****************************************************************************/
+void	CElemSet::Load3d(CCore *Core)
+{
+CScene	Scene;
+
+		Scene.Load(Filename);
+
+CNode	&ThisNode=Scene.GetSceneNode(0);
+int		ChildCount=ThisNode.GetPruneChildCount();
+		
+		ElemList.push_back(CElem(DefWidth,DefHeight));	// Insert Blank		
+		
+		for (int Child=0; Child<ChildCount; Child++) 
+		{
+			ElemList.push_back(CElem(Core,Filename,Scene,ThisNode.PruneChildList[Child]));
+		}
+		ElemBrowserWidth=DEF_ELEMBROWSWEWIDTH;
+}
+
+/*****************************************************************************/
+void	CElemSet::Purge()
+{
+int	ListSize=ElemList.size();
+	
+		for (int i=0; i<ListSize; i++)
+		{
+			ElemList[i].Purge();
+		}
+		ElemList.clear();
+		Loaded=FALSE;
+}
+
+/*****************************************************************************/
+CPoint	CElemSet::GetElemPos(int ID)
+{
+	if (ID==0)
+		return(CPoint(-1,-1));
+	else
+		return(IDToPoint(ID-1,ElemBrowserWidth));
+}
+
+/*****************************************************************************/
+bool	CElemSet::IsValid(int No)			
+{
+int		ListSize=ElemList.size();
+		if (No>ListSize) return(false);
+		return(ElemList[No].IsValid());
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*** Elem Bank ***************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+CElemBank::CElemBank()
+{
+		LoadFlag=FALSE;
+}
+
+/*****************************************************************************/
+CElemBank::~CElemBank()
+{
+}
+
+/*****************************************************************************/
+void	CElemBank::Load(CFile *File,int Version)
+{
+int		ListSize;
+GFName	RootPath=File->GetFilePath();
+GString	FilePath;
+char	FixPath[1024];
+
+		FilePath=RootPath.Drive();
+		FilePath+=RootPath.Dir();
+		FilePath.Append('\\');
+		FilePath.Upper();
+	
+		File->Read(&ListSize,sizeof(int));
+
+// New Style rel storage
+		for (int i=0;i<ListSize;i++)
+		{
+			char	c=1;
+			GString	FullName;//=FilePath;
+
+			while (c)
+			{
+				File->Read(&c,1);
+				FullName.Append(c);
+			}
+			FullName.Upper();
+			GFName::makeabsolute(FilePath,FullName,FixPath);
+			FullName=FixPath;
+			_fullpath( FixPath, FullName, 1024);
+			for (int z=0; z<strlen(FixPath); z++) 
+			{// Invalidate any long name short cackness
+				if (FixPath[z]=='~') FixPath[z]='_'; 
+			}
+			FullName=FixPath;
+
+			CheckFilename(FullName);
+			FullName.Upper();
+			AddSet(FullName);
+		}
+}
+
+/*****************************************************************************/
+void	CElemBank::Save(CFile *File)
+{
+int		ListSize=SetList.size();
+GFName	RootPath=File->GetFilePath();
+GString	SavePath;
+
+		SavePath=RootPath.Drive();
+		SavePath+=RootPath.Dir();
+		SavePath.Append('\\');
+
+		SavePath.Upper();
+
+		File->Write(&ListSize,sizeof(int));
+
+		for (int i=0; i<ListSize; i++)
+		{
+			char		Filename[256+64];
+			RootPath.makerelative(SavePath,SetList[i].GetFilename(),Filename);	
+			File->Write(Filename,strlen(Filename)+1);		
+		}
+
+}
+
+/*****************************************************************************/
+void	CElemBank::AddSet(const char *Filename)
+{
+int			ListSize=SetList.size();
+CElemSet	NewSet(Filename,ListSize);
+
+			SetList.Add(NewSet);
+			if (SetList.size()!=ListSize) LoadFlag=TRUE;
+}
+
+/*****************************************************************************/
+void	CElemBank::LoadAllSets(CCore *Core)
+{
+int		ListSize=SetList.size();
+	
+		if (!LoadFlag) return;
+
+		for (int i=0;i<ListSize;i++)
+		{
+			CElemSet	&ThisSet=SetList[i];
+
+			if (!ThisSet.IsLoaded()) ThisSet.Load(Core);
+		}
+		LoadFlag=false;
+}
+
+/*****************************************************************************/
+void	CElemBank::LoadNewSet(CCore *Core)
+{
+char		BASED_CODE GinFilter[]= "All Tile Files (*.Gin; *.Bmp)|*.gin;*.Bmp|3d Tile Files (*.Gin)|*.Gin|2d Tile Files (*.Bmp)|*.Bmp|All Files (*.*)|*.*||";
+CFileDialog	Dlg(TRUE,"Gin",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,GinFilter);
+
+		if (Dlg.DoModal()!=IDOK) return;
+
+char	Filename[256];
+		sprintf(Filename,"%s",Dlg.GetPathName());
+		AddSet(Filename);
+}
+
+/*****************************************************************************/
+void	CElemBank::ReloadAllSets()
+{
+int		ListSize=SetList.size();
+
+		for (int i=0; i<ListSize; i++)
+		{
+			SetList[i].Purge();
+		}
+
+		LoadFlag=TRUE;
+}
+
+/*****************************************************************************/
+void	CElemBank::DeleteSet(int Set)
+{
+		SetList.erase(Set);
+}
+
+/*****************************************************************************/
+CElem	&CElemBank::GetElem(int Set,int Elem)
+{
+		ASSERT(Set>=0 && Elem>=0);
+		return(SetList[Set].GetElem(Elem));
+}
+
+/*****************************************************************************/
+bool	CElemBank::IsValid(int Set,int Elem)
+{
+ 		if (Set<0 || Elem<0) return(false);
+		if (Elem==0) return(true);
+		ASSERT(Set<SetList.size());
+		return(SetList[Set].IsValid(Elem));
+}
 

Utils/MapEdit/Elem.h

@@ -33,62 +33,135 @@ public:
 		{
 			ElemType2d=0,
 			ElemType3d,
+			ElemTypeMax
 		};
-		enum	ElemEnums
+		enum
 		{
-			PCTexWidth	=16,
+			UnitSize=16,
-			PCTexHeight	=PCTexWidth,
 		};
 
-//		CElem();
+		CElem(int Width,int Height);																	// Blank (2d)
-		CElem(int Blank,int Width=PCTexWidth,int Height=PCTexHeight	);						// Blank (2d)
+		CElem(CCore *Core,const char *Filename,int TexId,int XOfs,int YOfs,int Width,int Height);		// 2d elem
-		CElem(CCore *Core,const char *Filename,int TexId,int XOfs,int YOfs);				// 2d elem
+		CElem(CCore *Core,const char *Filename,CScene &ThisScene,int Node);								// 3d elem
-		CElem(CCore *Core,const char *Filename,CScene &ThisScene,int Node);					// 3d elem
 
+		void	CleanUp();
 		void	Purge();
 		void	Render(int Flags,bool Render3d);
 
-		int		GetPCTexW()					{return(PCTexWidth);}
+		int		GetElemWidth()				{return(ElemWidth);}
-		int		GetPCTexH()					{return(PCTexHeight);}
+		int		GetElemHeight()				{return(ElemHeight);}
-		u8		*GetPCTexRGB()				{return(PCTexRGB);}
+		u8		*GetElemRGB()				{return(ElemRGB);}
 
 		bool	IsValid()					{return(ValidFlag);}
 
 		bool	IsElem3d()					{return(Type==ElemType3d);}
 		int		GetTexXOfs()				{return(TexXOfs);}
 		int		GetTexYOfs()				{return(TexYOfs);}
-		int		GetTexID()					{return(Tex2dID);}
 
+		void	CreateBlankTileGfx();
+		void	CreateInvalidTileGfx();
+		
 		std::vector<sTriFace> 	&GetTriList() {return(TriList);}
 
 protected:
 		void	Build3dElem(CTexCache &TexCache,CScene &ThisScene,int Node);
 		void	Build2dElem(CCore *Core,const char *Filename,int TexId);
-//		void	FixUp();
 		void	Build3dDrawList(CTexCache &TexCache,GLint &List);
 		void	Build2dDrawList(CTexCache &TexCache,GLint &List);
 
 		void	RenderElem4Texture(sRGBData &RGBData);
 		void	Create2dTexture(CTexCache &TexCache,const char *Filename,int ID);
 		bool	CheckHasData(sRGBData &RGBData);
-
+		void	Calc3dSize();
 		GString					SetPath;
 
 		std::vector<sTriFace>	TriList;
-		
 
 		Vector3					Ofs;
-		int						Width,Height;
 
-		GLint					DrawList[2];
+		GLint					DrawList[ElemTypeMax];
 		ElemType				Type;
 		bool					ValidFlag;
 		int						TexXOfs,TexYOfs;
-		int						Tex2dID;
 		
-//		char					PCTexName[256];
+		int						ElemWidth,ElemHeight;
-		int						PCTexID;
+		float					UnitWidth,UnitHeight;
-		u8						*PCTexRGB;
+		int						ElemID;
+		u8						*ElemRGB;
+
+};
+
+/*****************************************************************************/
+class	CElemSet
+{
+public:
+		enum
+		{
+			DEF_ELEMWIDTH=16,
+			DEF_ELEMHEIGHT=16,
+			DEF_ELEMBROWSWEWIDTH=8,
+		};
+
+		CElemSet(const char *_Filename,int Idx,int Width=DEF_ELEMWIDTH,int Height=DEF_ELEMHEIGHT);
+		~CElemSet();
+	
+		int			IsLoaded()										{return(Loaded);}
+		int			GetCount()										{return(ElemList.size());}
+
+		void		Load(CCore *Core);
+
+const	char		*GetFilename()									{return(Filename);}
+const	char		*GetName()										{return(Name);}
+		int			GetBrowserWidth()								{return(ElemBrowserWidth);}
+
+		void		RenderElem(int Elem,int Flags,bool Render3d)	{ElemList[Elem].Render(Flags,Render3d);}
+		CElem		&GetElem(int No)								{return(ElemList[No]);}
+		void		Purge();
+		bool		IsValid(int No);
+
+		bool		operator==(CElemSet const &v1)					{return (Name==v1.Name);}
+
+private:
+		void			Load2d(CCore *Core);
+		void			Load3d(CCore *Core);
+		
+		CPoint			GetElemPos(int ID);
+
+		GString			Filename,Name;
+		
+		int				SetNumber;
+		int				DefWidth,DefHeight;
+		CList<CElem>	ElemList;
+		bool			Loaded;
+		int				ElemBrowserWidth;
+};
+
+/*****************************************************************************/
+class	CElemBank
+{
+public:
+		CElemBank();
+		~CElemBank();
+
+		void		Load(CFile *File,int Version);
+		void		Save(CFile *File);
+
+		void		AddSet(const char *Filename);
+		void		LoadAllSets(CCore *Core);
+		void		LoadNewSet(CCore *Core);
+		void		ReloadAllSets();
+		void		DeleteSet(int Set);
+		int			NeedLoad()							{return(LoadFlag);}
+		CElem		&GetElem(int Set,int Elem);
+		bool		IsValid(int Set,int Elem);
+
+		int			GetSetCount()						{return(SetList.size());}
+	
+
+protected:
+
+		CList<CElemSet>	SetList;
+		bool			LoadFlag;
 
 };
 

Utils/MapEdit/Export.cpp

@@ -13,7 +13,7 @@
 #include	"Core.h"
 #include	"TexCache.h"
 #include	"TileSet.h"
-#include	"Tile.h"
+#include	"Elem.h"
 
 #include	"Layer.h"
 #include	"LayerTile.h"
@@ -30,6 +30,11 @@ CExport::CExport(char *Filename)
 // Write Dummy File Header
 
 		fwrite(&FileHdr,sizeof(sExpFileHdr),1,File);
+
+// Add blank tile
+
+sExpTile	BlankElem={0,0,0,0,0,0,0};
+		AddTile(BlankElem);
 }
 
 /*****************************************************************************/
@@ -81,8 +86,10 @@ void	CExport::ExportTiles(CCore *Core)
 int		ListSize,i;
 CTileBank	*TileBank=Core->GetTileBank();
 
-		FileHdr.TileW=TileBank->GetTile(1,0).GetPCTexW();
+//!!		FileHdr.TileW=TileBank->GetTile(0,0).GetElemWidth();
-		FileHdr.TileH=TileBank->GetTile(1,0).GetPCTexH();
+//!!		FileHdr.TileH=TileBank->GetTile(0,0).GetElemHeight();
+		FileHdr.TileW=16;
+		FileHdr.TileH=16;
 
 // Write Tiles
 		ListSize=UsedTileList.size();
@@ -108,37 +115,32 @@ CTileBank	*TileBank=Core->GetTileBank();
 void	CExport::ExportTile(CCore *Core,sExpTile &OutTile)
 {
 CTileBank	*TileBank=Core->GetTileBank();
-CTile		&ThisTile=TileBank->GetTile(OutTile.Set,OutTile.Tile);
-int			RGBW=ThisTile.GetPCTexW();
-int			RGBH=ThisTile.GetPCTexH();
-u8			*RGB=ThisTile.GetPCTexRGB();
-GString		SetName=TileBank->GetSet(OutTile.Set).GetFilename();
 
-		if (ThisTile.IsTile3d())
+		if (OutTile.Set==0 && OutTile.Tile==0)
 		{
-			ExportTile3d(Core,ThisTile,OutTile);
+			char	c=0;
+
+			fwrite(&OutTile,sizeof(sExpTile),1,File);
+			fwrite(&c,1,16*16*3,File);	// Write RGB
 		}
 		else
 		{
+			CElem		&ThisTile=TileBank->GetTile(OutTile.Set,OutTile.Tile);
+			GString		SetName=TileBank->GetSetFilename(OutTile.Set);
+
+			ASSERT(ThisTile.GetElemWidth()==FileHdr.TileW);
+			ASSERT(ThisTile.GetElemHeight()==FileHdr.TileH);
+			if (ThisTile.IsElem3d()) ExportTile3d(Core,ThisTile,OutTile);
+			OutTile.Set=SetNames.Add(SetName);
+			fwrite(&OutTile,sizeof(sExpTile),1,File);
+			fwrite(ThisTile.GetElemRGB(),FileHdr.TileW*FileHdr.TileH*3,1,File);	// Write RGB
 		}
 
-// change set name to set mappping
-		if (OutTile.Set==0) 
-		{
-			SetName="BLANK";
-		}
-
-		OutTile.Set=SetNames.Add(SetName);
-		fwrite(&OutTile,sizeof(sExpTile),1,File);
-// Write RGB
-		ASSERT(RGBW==FileHdr.TileW);
-		ASSERT(RGBH==FileHdr.TileH);
-		fwrite(RGB,RGBW*RGBH*3,1,File);
 
 }
 
 /*****************************************************************************/
-void	CExport::ExportTile3d(CCore *Core,CTile &ThisTile,sExpTile &OutTile)
+void	CExport::ExportTile3d(CCore *Core,CElem &ThisTile,sExpTile &OutTile)
 {
 CTexCache				&TexCache=Core->GetTexCache();
 std::vector<sTriFace>	&TileTriList=ThisTile.GetTriList();
@@ -185,6 +187,7 @@ char		RelStr[256];
 			ThisFile.Upper();
 			GFName::makerelative(SavePath,ThisFile,RelStr);
 			fwrite(RelStr,strlen(RelStr)+1,1,File);
+			TRACE2("Set %i:%s\n",i,RelStr);
 		}
 // Tex List
 		ListSize=TexNames.size();
@@ -197,6 +200,7 @@ char		RelStr[256];
 			ThisFile.Upper();
 			GFName::makerelative(SavePath,ThisFile,RelStr);
 			fwrite(RelStr,strlen(RelStr)+1,1,File);
+			TRACE2("Tex %i:%s\n",i,RelStr);
 		}
 
 }

Utils/MapEdit/Export.h

@@ -34,8 +34,8 @@ public:
 
 protected:
 		void	ExportTile(CCore *Core,sExpTile	&ThisElem);
-		void	ExportTile3d(CCore *Core,CTile &ThisTile,sExpTile &OutTile);
+		void	ExportTile3d(CCore *Core,CElem &ThisTile,sExpTile &OutTile);
-		void	ExportTile2d(CCore *Core,CTile &ThisTile,sExpTile &OutTile);
+		void	ExportTile2d(CCore *Core,CElem &ThisTile,sExpTile &OutTile);
 
 		sExpFileHdr			FileHdr;
 		

Utils/MapEdit/ExportHdr.h

@@ -6,8 +6,6 @@
 #define	__EXPORT_STRUCTS_HEADER__
 
 #include	<Vector>
-//#include	"GinTex.h"
-//#include	"Tile.h"
 
 #include	<List.h>
 

Utils/MapEdit/Layer.cpp

@@ -31,6 +31,7 @@ int		CLayer::InfoTableSize=sizeof(InfoTable)/sizeof(sLayerInfoTable);
 CLayer::CLayer()
 {
 	SubView=0;
+	LayerCam=DefaultCamPos;
 }
 
 /*****************************************************************************/

Utils/MapEdit/Layer.h

@@ -78,16 +78,17 @@ virtual	void			GUIKill(CCore *Core)=0;
 virtual	void			GUIUpdate(CCore *Core)=0;
 virtual	void			GUIChanged(CCore *Core)=0;
 
-virtual	int				GetWidth()=0;
+virtual	int				GetWidth()						{return(-1);}
-virtual	int				GetHeight()=0;
+virtual	int				GetHeight()						{return(-1);}
 virtual	void			CheckLayerSize(int Width,int Height){};
-virtual	bool			Resize(int Width,int Height)=0;
+virtual	bool			Resize(int Width,int Height)	{return(false);}
 
 virtual	void			Load(CFile *File,int Version)=0;
 virtual	void			Save(CFile *File)=0;
 
 virtual	void			Export(CCore *Core,CExport &Exp)=0;
 
+virtual	Vector3			&GetCam()						{return(LayerCam);}
 
 // Functions
 virtual	bool			LButtonControl(CCore *Core,UINT nFlags, CPoint &CursorPos,bool DownFlag){return(false);}
@@ -103,6 +104,8 @@ protected:
 		bool			VisibleFlag;
 		CSelect			Selection;
 		CLayer			*SubView;
+		Vector3			LayerCam;
+
 };
 
 

Utils/MapEdit/LayerCollision.cpp

@@ -21,6 +21,9 @@
 #include	"Select.h"
 #include	"Export.h"
 
+// Reserve slot 0 for collision :o)
+GString		ColFName="Collision.bmp";
+
 /*****************************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
@@ -31,6 +34,7 @@ CLayerCollision::CLayerCollision(int _SubType,int Width,int Height)
 		SetDefaultParams();
 		Mode=MouseModePaint;
 		Map.SetSize(Width,Height,TRUE);
+		VisibleFlag=true;
 }
 
 /*****************************************************************************/
@@ -43,6 +47,32 @@ CLayerCollision::CLayerCollision(CFile *File,int Version)
 /*****************************************************************************/
 CLayerCollision::~CLayerCollision()
 {
+		delete TileBank;
+}
+
+/*****************************************************************************/
+void	CLayerCollision::InitSubView(CCore *Core)
+{
+		TileBank=new CTileBank;
+		SubView=TileBank;
+
+GFName	ExePath;
+GString	Filename;
+
+// Get application path
+#ifdef _DEBUG
+		ExePath="C:\\Spongebob\\tools\\mapedit\\";
+#else
+char	ExeFilename[2048];
+		GetModuleFileName(GetModuleHandle(NULL),ExeFilename,2048);
+		ExePath=ExeFilename;
+		ExePath.File(0);
+ 		ExePath.Ext(0);
+#endif
+		Filename=ExePath.FullName();
+		Filename+=ColFName;
+		TileBank->AddSet(Filename);
+
 }
 
 /*****************************************************************************/
@@ -81,7 +111,7 @@ void	CLayerCollision::Render(CCore *Core,Vector3 &CamPos,bool Is3d)
 {
 Vector3		ThisCam=Core->OffsetCam(CamPos,GetScaleFactor());
 
-			CLayerTile::Render(Core,ThisCam,Map,FALSE,0.5f);
+			CLayerTile::Render(Core,ThisCam,Map,false,0.5f);
 }
 
 /*****************************************************************************/
@@ -162,19 +192,3 @@ int		Height=Map.GetHeight();
 		}
 
 }
-
-/*****************************************************************************/
-/*
-void	CLayerCollision::DeleteSet(int Set)
-{
-		Map.DeleteSet(Set);
-}
-*/
-/*****************************************************************************/
-/*
-void	CLayerCollision::RemapSet(int OrigSet,int NewSet)
-{
-		Map.RemapSet(OrigSet,NewSet);
-
-}
-*/

Utils/MapEdit/LayerCollision.h

@@ -20,6 +20,7 @@ public:
 		~CLayerCollision();
 
 		int				GetType()			{return(LAYER_TYPE_COLLISION);}
+		void			InitSubView(CCore *Core);
 
 		void			Render(CCore *Core,Vector3 &CamPos,bool Is3d);
 
@@ -38,7 +39,7 @@ public:
 		void			DeleteSet(int Set);
 		void			RemapSet(int OrigSet,int NewSet);
 protected:
-
+		void			InitTileBank();
 
 		CLayerCollisionGUI	CollisionGUI;
 

Utils/MapEdit/LayerTile.cpp

@@ -110,11 +110,11 @@ void	CLayerTile::Save(CFile *File)
 void	CLayerTile::InitSubView(CCore *Core)
 {
 // Fix up shared layers
-		if (!SubView)
+		if (SubType!=LAYER_SUBTYPE_ACTION)
 		{
-			SubView=Core->FindSubView(LAYER_SUBVIEW_TILEBANK);
+			TileBank=Core->GetTileBank();
+			SubView=(CLayer*)TileBank;
 		}
-		TileBank=(CTileBank*)SubView;
 }
 
 /*****************************************************************************/
@@ -154,16 +154,8 @@ void	CLayerTile::Render(CCore *Core,Vector3 &CamPos,bool Is3d)
 {
 Vector3		ThisCam=Core->OffsetCam(CamPos,GetScaleFactor());
 
-		if (Is3d && Render3dFlag)
+		Is3d&=Render3dFlag;
-		{
+		Render(Core,ThisCam,Map,Is3d);
-			glEnable(GL_DEPTH_TEST);
-			Render(Core,ThisCam,Map,TRUE);
-			glDisable(GL_DEPTH_TEST);
-		}
-			else
-		{
-			Render(Core,ThisCam,Map,FALSE);
-		}
 }
 
 /*****************************************************************************/
@@ -206,10 +198,12 @@ float		ScrOfsX=(ZoomW/2);
 float		ScrOfsY=(ZoomH/2);
 Vector3		&Scale=Core->GetScaleVector();
 bool		WrapMap=SubType==LAYER_SUBTYPE_BACK;
-int		StartX=(int)ThisCam.x;
+int			StartX=(int)ThisCam.x;
-int		StartY=(int)ThisCam.y;
+int			StartY=(int)ThisCam.y;
-float	ShiftX=ThisCam.x - (int)ThisCam.x;
+float		ShiftX=ThisCam.x - (int)ThisCam.x;
-float	ShiftY=ThisCam.y - (int)ThisCam.y;
+float		ShiftY=ThisCam.y - (int)ThisCam.y;
+
+		if (TileBank->NeedLoad()) TileBank->LoadAllSets(Core);
 
 		if (StartX<0) StartX=0;
 		if (StartY<0) StartY=0;
@@ -251,12 +245,10 @@ int		DrawH=ZoomH+8;
 				}
 				
 				sMapElem	&ThisElem=ThisMap.Get(XPos,YPos);
-				if (ThisElem.Tile && TileBank->IsTileValid(ThisElem.Set,ThisElem.Tile))
+				if (ThisElem.Tile>0)
-				{ // Render Non Zero Tiles
+				{ // Render Non Zero and Valid Tiles
-					CTile		&ThisTile=TileBank->GetTile(ThisElem.Set,ThisElem.Tile);
-
 					glColor4f(1,1,1,Alpha);	// Set default Color
-					ThisTile.Render(ThisElem.Flags,Render3d);
+					TileBank->RenderTile(ThisElem.Set,ThisElem.Tile,ThisElem.Flags,Render3d);
 				}
 				glTranslatef(1.0f,0,0);	// Next X
 			}
@@ -584,6 +576,7 @@ bool	Ret=false;
 		case CmdMsg_ActiveBrushLeft:
 		case CmdMsg_ActiveBrushRight:
 			Ret=TileBank->Command(CmdMsg,Core,Param0,Param1);
+			break;
 		default:
 			TRACE3("LayerTile-Unhandled Command %i (%i,%i)\n",CmdMsg,Param0,Param1);
 		}
@@ -634,7 +627,6 @@ bool	CLayerTile::MirrorX(CCore *Core)
 /*****************************************************************************/
 bool	CLayerTile::MirrorY(CCore *Core)
 {
-//		if (GetType()==LAYER_TYPE_COLLISION) return(false);
 		switch(Mode)
 		{
 		case MouseModePaint:
@@ -714,7 +706,7 @@ CRect		Rect=Selection.GetRect();
 
 bool	CLayerTile::Paint(CMap &Blk,CPoint &CursorPos)
 {
-		if (CursorPos.y==-1 || CursorPos.y==-1) return(FALSE);	// Off Map?
+		if (CursorPos.x==-1 || CursorPos.y==-1) return(FALSE);	// Off Map?
 		if (!Blk.IsValid()) return(FALSE);	// Invalid tile?
 
 		Map.Set(CursorPos.x,CursorPos.y,Blk);
@@ -727,38 +719,45 @@ void	CLayerTile::Export(CCore *Core,CExport &Exp)
 {
 int				Width=Map.GetWidth();
 int				Height=Map.GetHeight();
-sExpTile		BlankElem={0,0,0,0};
 
 		Exp.ExportLayerHeader(LAYER_TYPE_TILE,SubType,Width,Height);
 
-		Exp.AddTile(BlankElem);	// Ensure blank tile is present
-		
 		for (int Y=0; Y<Height; Y++)
 		{
 			for (int X=0; X<Width; X++)
 			{
 				sMapElem		&MapElem=Map.Get(X,Y);
-				CTile			&ThisTile=TileBank->GetTile(MapElem.Set,MapElem.Tile);
 				sExpLayerTile	OutElem;
-				sExpTile		OutTile;
 
-				OutTile.Set=MapElem.Set;
+				if (MapElem.Set==0 && MapElem.Tile==0)
-				OutTile.Tile=MapElem.Tile;
+				{ // Blank
-				OutTile.TriCount=0;
+					OutElem.Tile=0;
-				OutTile.XOfs=ThisTile.GetTexXOfs();
+					OutElem.Flags=0;
-				OutTile.YOfs=ThisTile.GetTexYOfs();
+				}
-				
+				else
-				OutElem.Tile=Exp.AddTile(OutTile);
+				{
-				OutElem.Flags=MapElem.Flags;
+					sExpTile		OutTile;
+					CElem			&ThisTile=TileBank->GetTile(MapElem.Set,MapElem.Tile);
+
+					OutTile.Set=MapElem.Set;
+					OutTile.Tile=MapElem.Tile;
+					OutTile.TriStart=0;
+					OutTile.TriCount=0;
+					OutTile.XOfs=ThisTile.GetTexXOfs();
+					OutTile.YOfs=ThisTile.GetTexYOfs();
+					OutElem.Tile=Exp.AddTile(OutTile);
+					OutElem.Flags=MapElem.Flags;
+				}
+
 				Exp.Write(&OutElem,sizeof(sExpLayerTile));
 			}
 		}
 }
 
 /*****************************************************************************/
-void	CLayerTile::DeleteSet(int Set)
+void	CLayerTile::RemoveSet(int Set)
 {
-		Map.DeleteSet(Set);
+		Map.RemoveSet(Set);
 }
 
 /*****************************************************************************/

Utils/MapEdit/LayerTile.h

@@ -68,7 +68,7 @@ virtual	bool			Command(int CmdMsg,CCore *Core,int Param0=0,int Param1=0);
 
 // Local
 		CTileBank		*GetTileBank()		{return(TileBank);}
-		void			DeleteSet(int Set);
+		void			RemoveSet(int Set);
 		void			RemapSet(int OrigSet,int NewSet);
 
 protected:

Utils/MapEdit/Map.cpp

@@ -17,7 +17,7 @@ void	CMap::Load(CFile *File,int Version)
 // Version 1
 int	Width;
 int	Height;
-int	VFix=0;	// Fix for colliison tileset
+int	VFix=0;	// Fix for New tileset shash
 
 		if (Version<2) VFix=1;
 
@@ -33,6 +33,15 @@ int	VFix=0;	// Fix for colliison tileset
 				sMapElem	ThisElem;
 				File->Read(&ThisElem,sizeof(sMapElem));
 				ThisElem.Set+=VFix;
+				if (Version==3) 
+				{
+					ThisElem.Set--;
+					if (ThisElem.Set<0)
+					{
+						ThisElem.Set=0;
+					}
+				}
+
 				Set(X,Y,ThisElem,TRUE);
 			}
 		}
@@ -312,7 +321,7 @@ int		MinH=min(Height,OldHeight);
 }
 
 /*****************************************************************************/
-void	CMap::DeleteSet(int Set)
+void	CMap::RemoveSet(int Set)
 {
 int		Width=GetWidth();
 int		Height=GetHeight();

Utils/MapEdit/Map.h

@@ -55,7 +55,7 @@ public:
 		void		Load(CFile *File,int Version);
 		void		Save(CFile *File);
 
-		void		DeleteSet(int Set);
+		void		RemoveSet(int Set);
 		void		RemapSet(int Old,int New);
 
 

Utils/MapEdit/MapEdit.dsp

@@ -69,7 +69,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /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" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\libs\glib" /I "..\libs\maths" /I "..\libs\davelib" /I "..\libs\ginlib" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR /Yu"stdafx.h" /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x809 /d "_DEBUG" /d "_AFXDLL"
@@ -160,6 +160,14 @@ SOURCE=.\Core.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\Elem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Elem.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\Map.cpp
 # End Source File
 # Begin Source File
@@ -176,14 +184,6 @@ SOURCE=.\TexCache.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\Tile.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\Tile.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\TileSet.cpp
 # End Source File
 # Begin Source File

Utils/MapEdit/TileSet.h

@@ -14,7 +14,7 @@
 
 #include	"Layer.h"
 #include	"TexCache.h"
-#include	"Tile.h"
+#include	"Elem.h"
 
 #include	"MapEdit.h"
 #include	"LayerTileGui.h"
@@ -27,11 +27,9 @@ DefTileBrowserWidth=8,
 
 /*****************************************************************************/
 class	CCore;
-class	CTile;
 
 /*****************************************************************************/
-class	CTileSet;
+class	CTileBank : public CLayer, public CElemBank
-class	CTileBank : public CLayer
 {
 public:
 		CTileBank();
@@ -57,11 +55,6 @@ public:
 		void		GUIUpdate(CCore *Core);
 		void		GUIChanged(CCore *Core);
 
-		int			GetWidth(){return(0);}
-		int			GetHeight(){return(0);}
-		void		CheckLayerSize(int Width,int Height){};
-		bool		Resize(int Width,int Height){return(false);}
-
 		void		Load(CFile *File,int Version);
 		void		Save(CFile *File);
 
@@ -72,30 +65,25 @@ public:
 		bool		MouseMove(CCore *Core,UINT nFlags, CPoint &CursorPos);
 		bool		Command(int CmdMsg,CCore *Core,int Param0=0,int Param1=0);
 
+// ElemSet Thruput
+const	char		*GetSetName(int Set)									{return(SetList[Set].GetName());}
+const	char		*GetSetFilename(int Set)								{return(SetList[Set].GetFilename());}
+		CElem		&GetTile(int Set,int Tile)								{return(SetList[Set].GetElem(Tile));}
+		void		RenderTile(int Set,int Elem,int Flags,bool Is3d)		{SetList[Set].RenderElem(Elem,Flags,Is3d);}
+
 // Local
-		void		AddTileSet(const char *Filename);
-		int			NeedLoad()							{return(LoadFlag);}
 		void		DeleteCurrent();
-		void		ReloadAll();
-		void		LoadTileSets(CCore *Core);
-		CTile		&GetTile(int Bank,int Tile);
 		
-		int			GetSetCount()						{return(TileSet.size());}
+		CMap		&GetLBrush()											{return(Brush[LBrush]);}
-		
+		CMap		&GetRBrush()											{return(Brush[RBrush]);}
-		CMap		&GetLBrush()						{return(Brush[LBrush]);}
+		CMap		&GetBrush(int i)										{return(Brush[i]);}
-		CMap		&GetRBrush()						{return(Brush[RBrush]);}
+		CMap		&GetActiveBrush()										{return(GetBrush(ActiveBrush));}
-		CMap		&GetBrush(int i)					{return(Brush[i]);}
-		CMap		&GetActiveBrush()					{return(GetBrush(ActiveBrush));}
 
-		bool		IsTileValid(int Set,int Tile);
+		bool		CanClose()												{return(SelStart==-1);}
-		bool		CanClose()							{return(SelStart==-1);}
+		CPoint		GetTilePos(int ID,int Width);
-
-		void		SetCollision(bool f);
-		CTileSet	&GetSet(int Set)					{return(TileSet[Set]);}
 
 // Functions
 		bool		SelectCancel();
-		void		LoadSet(CCore *Core);
 		void		DeleteSet(CCore *Core);
 
 
@@ -104,7 +92,7 @@ protected:
 		bool		Select(int BrushID,bool DownFlag);
 		void		SetBrush(CMap &ThisBrush);
 
-		CList<CTileSet>			TileSet;
+//!!		CList<CTileSet>			TileSet;
 		int						CurrentSet,LastSet;
 		CMap					Brush[2];
 		int						ActiveBrush;
@@ -117,48 +105,5 @@ protected:
 
 };
 
-/*****************************************************************************/
-class	CTileSet
-{
-public:
-		CTileSet(const char *_Filename,int Idx);
-		~CTileSet();
-		
-		int			IsLoaded()			{return(Loaded);}
-		int			GetTileCount()		{return(Tile.size());}
-
-		void		Load(CCore *Core);
-		void		Load2d(CCore *Core);
-		void		Load3d(CCore *Core);
-
-const	char		*GetFilename()		{return(Filename);}
-const	char		*GetName()			{return(Name);}
-
-		CTile		&GetTile(int No)	{return(Tile[No]);}
-		void		Purge();
-		int			FindCursorPos(CCore *Core,Vector3 &CamPos,CPoint &MousePos);
-		void		Render(CCore *Core,Vector3 &CamPos,CMap &LBrush,CMap &RBrush,bool Render3d);
-		void		RenderCursor(Vector3 &CamPos,int Pos,int Width, int Height);
-		void		RenderBrush(Vector3 &CamPos,CMap &LBrush,CMap &RBrush);
-		void		RenderGrid(CCore *Core,Vector3 &CamPos,bool Active);
-		int			GetTileBrowserWidth()		{return(TileBrowserWidth);}
-		bool		IsTileValid(int No);
-
-bool			operator==(CTileSet const &v1)		{return (Name==v1.Name);}
-
-//			if (IsStrSame((char*)Name,(char*)v1.Name) return(i);
-
-private:
-		bool		Create16x16Tile(sRGBData &Src,u8 *Dst,int XOfs,int YOfs);
-		CPoint		GetTilePos(int ID);
-
-		GString			Filename,Name;
-		
-		int				SetNumber;
-		CList<CTile>	Tile;
-		bool			Loaded;
-		int				TileBrowserWidth;
-};
-
 /*****************************************************************************/
 #endif

Utils/MapEdit/utils.cpp

@@ -324,3 +324,15 @@ CFileDialog	Dlg(true,NULL,Name,OFN_HIDEREADONLY | OFN_PATHMUSTEXIST,Filter);
 }
 
 /*****************************************************************************/
+int		round(float f) 
+{
+		if (f<0) 
+		{
+			return (int)(f-0.5f);
+		} 
+		else 
+		{
+			return (int)(f+0.5f);
+		}
+}
+/*****************************************************************************/

Utils/MapEdit/utils.h

@@ -53,6 +53,7 @@ void	MakeFullFilename(const char *RelName,GString &Out);
 void	MakePathRel2App(const char* In,char *Out);
 GString	GetWorkingPath();
 void	CheckFilename(GString &Filename);
+int		round(float f) ;
 
 	
 #endif

Utils/MkActor3d/MkActor3d.cpp

@@ -129,7 +129,6 @@ vector<GString> const &Files = MyFiles.GetFileInfoVector();
 		for (i=0; i<ListSize; i++)
 		{
 			ActorList[i].ActorWrite();
-			ActorList[i].AnimWrite();
 		}
 
 		return 0;
@@ -397,11 +396,15 @@ GString	OutName=OutFile+".A3d";
 // Write TexList
 		FileHdr.TexInfo=(sTexInfo*)WriteTexInfoList();
 
-		printf("S:%i\n",ftell(File));
+// Write anims
+		AnimWrite();
 
 // Rewrite Header
 		fseek(File, 0, SEEK_SET);
 		fwrite(&FileHdr,1,sizeof(sActorHdr),File);
+		fclose(File);
+
+		AnimWriteInclude();
 }
 
 //***************************************************************************
@@ -492,7 +495,7 @@ int		ListSize=InAnimList.size();
 			AnimList.push_back(ThisAnim);
 
 			ThisBoneCount=ThisAnim.BoneAnim.size();
-			printf("\t(%i Bones, %i Frames)\n",ThisBoneCount,ThisAnim.FrameCount);
+			printf("\t(%i Frames)\n",ThisAnim.FrameCount);
 
 // Check Skeleton
 			if (BoneCount!=ThisBoneCount)
@@ -557,21 +560,17 @@ int			ChildCount=ThisNode.GetPruneChildCount();
 //***************************************************************************
 void	CMkActor3d::AnimWrite()
 {
-GString			OutName=OutFile+".Abk";
 int				Anim,AnimCount=AnimList.size();
-sAnimFileHdr	FileHdr;
 sAnimHdr		Hdr;
+int				HdrPos;
 
-		if (!AnimCount) return;	// No anims, dont bother
+// FileHdr		
-		File=fopen(OutName,"wb");
-
-// Write Dummy FileHdr		
 		FileHdr.AnimCount=AnimCount;
-		FileHdr.BoneCount=BoneCount;
+		if (!AnimCount) return;	// No anims, dont bother
-		fwrite(&FileHdr,1,sizeof(sAnimFileHdr),File);
 
 // Write Dummy AnimHdrs
-
+		HdrPos=ftell(File);
+		FileHdr.AnimList=(sAnimHdr*)HdrPos;
 		for (Anim=0; Anim<AnimCount; Anim++)
 		{
 			fwrite(&Hdr,1,sizeof(sAnimHdr),File);
@@ -592,12 +591,8 @@ sAnimHdr		Hdr;
 			AnimList[Anim].AnimOfs=AnimWriteAnim(AnimList[Anim]);
 		}
 
-// ReWrite FileHdr
-		fseek(File, 0, SEEK_SET);
-		fwrite(&FileHdr,1,sizeof(sAnimFileHdr),File);
-
 // Rewrite Dummy AnimHdrs
-
+		fseek(File,HdrPos,SEEK_SET);
 		for (Anim=0; Anim<AnimCount; Anim++)
 		{
 			Hdr.FrameCount=AnimList[Anim].FrameCount;
@@ -605,9 +600,7 @@ sAnimHdr		Hdr;
 			Hdr.Anim=(u16*)AnimList[Anim].AnimOfs;
 			fwrite(&Hdr,1,sizeof(sAnimHdr),File);
 		}
-	
+
-		fclose(File);
-		if (!IncludeFile.Empty()) AnimWriteInclude();
 }
 
 //***************************************************************************
@@ -663,6 +656,7 @@ int		ListSize=QuatList.size();
 void	CMkActor3d::AnimWriteInclude()
 {
 GString	Filename=IncFile+"_Anim.h";
+FILE	*File;
 
 		File=fopen(Filename,"wt");