Utils/Libs/DaveLib/facestore.cpp

@@ -266,6 +266,7 @@ int			V=ThisTex.v+H;
 				Out.TPage|=In.TPageFlag<<5;
 			}
 		}
+
 }
 
 
@@ -677,6 +678,7 @@ int		c = FaceList.size();
 	FaceList[minF].Avail = false;
 	F.Normal= FaceList[minF].Normal;
 	F.OtOfs=FaceList[minF].OtOfs;
+	F.TPageFlag=FaceList[minF].TPageFlag;
 
 	if (minC && MaxStrip>F.pts.size()) FollowFace( minF, F );
 

Utils/MkLevel/MkLevel.cpp

@@ -244,7 +244,7 @@ int			i,ListSize=ModelList.size();
 				if (OtOfs)
 					printf("ModelOTOfs %s %i\n",ThisModel.Name,OtOfs);
 			
-				ThisModel.ElemID=Create3dElem(ThisModel.TriCount,ThisModel.TriStart,false,false,OtOfs);	// always all models as global for the moment
+				ThisModel.ElemID=Create3dElem(ThisModel.TriCount,ThisModel.TriStart,false,OtOfs);	// always all models as global for the moment
 			}
 }
 
@@ -278,7 +278,7 @@ int			Size;
 
 			LoadTiles(FileHdr);
 			LoadLayers(FileHdr);
-			SnapTiles();
+			if (SnapThresh!=0.0f) SnapTiles();
 
 			free(FileHdr);
 }
@@ -577,7 +577,7 @@ CFaceStore		&ThisList=ThisElem.FaceStore;
 			ThisList.setMaxStripLength(StripLength);
 			ThisElem.Elem3d.TriStart=OutTriList.size();
 			ThisElem.Elem3d.QuadStart=OutQuadList.size();
-			if (!ThisElem.LocalGeom)
+			if (!LocalGeom)
 			{ // Global Geom
 				ThisList.Process(OutTriList,OutQuadList,OutVtxList);
 				CalcOtOfs(OutTriList,OutVtxList,ThisElem.Elem3d.TriStart,ThisList.GetTriFaceCount());
@@ -586,29 +586,34 @@ CFaceStore		&ThisList=ThisElem.FaceStore;
 			else
 			{ // Local Geom
 				vector<sVtx>	LocalVtxList;
-				AddDefVtx(LocalVtxList);
+				int		VtxStart=0;
+
+				if (!ThisElem.Model)
+				{
+					AddDefVtx(LocalVtxList);
+					VtxStart=8;
+				}
+
 				ThisList.Process(OutTriList,OutQuadList,LocalVtxList);
 				ThisElem.Elem3d.VtxIdxStart=OutLocalVtxIdxList.size();
 				
 				int		ListSize=LocalVtxList.size();
 				int		LocalVtxCount=0;
 
-				for (int v=8; v<ListSize; v++)
+				for (int v=VtxStart; v<ListSize; v++)
 				{
 					u16	Idx=CFaceStore::AddVtx(OutVtxList,LocalVtxList[v]);
 
 					OutLocalVtxIdxList.push_back(Idx);
 					LocalVtxCount++;
 				}
-				if (LocalVtxCount<=0) 
+				if (LocalVtxCount==0) 
 				{
 					LocalOptCount++;
 					LocalVtxCount=0;
 				}
 				ThisElem.Elem3d.VtxTriCount=LocalVtxCount/3;
 				if (LocalVtxCount%3) ThisElem.Elem3d.VtxTriCount++;
-//				printf("%i=%i\n",LocalVtxCount,ThisElem.Elem3d.VtxTriCount);
-				
 				
 				CalcOtOfs(OutTriList,LocalVtxList,ThisElem.Elem3d.TriStart,ThisList.GetTriFaceCount());
 				CalcOtOfs(OutQuadList,LocalVtxList,ThisElem.Elem3d.QuadStart,ThisList.GetQuadFaceCount());
@@ -767,18 +772,18 @@ sExpTile	&SrcTile=InTileList[Tile];
 int			ElemID;
 			if (SrcTile.TriCount)
 			{
-				ElemID=Create3dElem(SrcTile.TriCount,SrcTile.TriStart,LocalGeom,true,0);
+				ElemID=Create3dElem(SrcTile.TriCount,SrcTile.TriStart,true,0);
 			}
 			else
 			{
-				ElemID=Create2dElem(Tile,LocalGeom);
+				ElemID=Create2dElem(Tile);
 			}
 
 			return(ElemID);
 }
 
 //***************************************************************************
-int		CMkLevel::Create3dElem(int TriCount,int TriStart,bool Local,bool IsTile,int OtOfs)
+int		CMkLevel::Create3dElem(int TriCount,int TriStart,bool IsTile,int OtOfs)
 {
 CFace			F;
 int				i,ListSize;
@@ -790,7 +795,6 @@ int				ElemID=OutElem3d.size();
 sOutElem3d		&ThisElem=OutElem3d[ElemID];
 CFaceStore		&FaceList=ThisElem.FaceStore;
 				FaceList.SetTexGrab(TexGrab);
-				ThisElem.LocalGeom=Local;
 
 			for (i=0; i<TriCount; i++)
 			{
@@ -839,15 +843,14 @@ CFaceStore		&FaceList=ThisElem.FaceStore;
 				FaceList.AddFace(F,true);
 				
 			}
-		if (IsTile)
+
-			ThisElem.Model=false;
+			ThisElem.Model=!IsTile;
-		else
+
-			ThisElem.Model=true;
+			return(ElemID);			
-		return(ElemID);			
 }
 
 //***************************************************************************
-int			CMkLevel::Create2dElem(int Tile,bool Local)
+int			CMkLevel::Create2dElem(int Tile)
 {
 CFace			F;
 int				i;
@@ -858,7 +861,6 @@ int				ElemID=OutElem3d.size();
 sOutElem3d		&ThisElem=OutElem3d[ElemID];
 CFaceStore		&FaceList=ThisElem.FaceStore;
 				FaceList.SetTexGrab(TexGrab);
-				ThisElem.LocalGeom=Local;
 
 			for (i=0; i<2; i++)
 			{
@@ -869,7 +871,6 @@ CFaceStore		&FaceList=ThisElem.FaceStore;
 
 				for (int p=0; p<3; p++)
 				{
-//					F.vtx[p]=ThisTri.vtx[p];
 					F.vtx[p].x=+ThisTri.vtx[p].x;
 					F.vtx[p].y=-ThisTri.vtx[p].y;
 					F.vtx[p].z=+ThisTri.vtx[p].z;
@@ -881,6 +882,8 @@ CFaceStore		&FaceList=ThisElem.FaceStore;
 				FaceList.SetTPageFlag(F,0);
 				FaceList.AddFace(F,true);
 			}
+			ThisElem.Model=false;
+			ThisElem.OTOfs=0;
 			return(ElemID);
 }
 

Utils/MkLevel/MkLevel.h

@@ -58,7 +58,7 @@ bool	operator ==(sUsedTile3d const &v1)	{return(Tile==v1.Tile);}
 
 struct sOutElem3d
 {
-		bool			LocalGeom;
+//		bool			LocalGeom;
 		bool			Model;
 		sElem3d			Elem3d;
 		CFaceStore		FaceStore;
@@ -118,8 +118,8 @@ public:
 protected:	
 		void			BuildModel(CScene &ThisScene,GString &RootPath,int Node);
 
-		int				Create3dElem(int TriCount,int TriStart,bool Local,bool IsTile,int OtOfs);
+		int				Create3dElem(int TriCount,int TriStart,bool IsTile,int OtOfs);
-		int				Create2dElem(int Tile,bool Local);
+		int				Create2dElem(int Tile);
 
 		CMkLevelLayer	*FindLayer(int Type,int SubType);
 		void			LoadStrList(CList<GString> &List,char *TexPtr,int Count);

source/fx/fxfallingtile.cpp

@@ -11,6 +11,7 @@
 #include	"level\level.h"
 #include	"level\layertile3d.h"
 #include	"system\vid.h"
+#include	"gfx\actor.h"
 
 #include	"FX\FXfallingTile.h"
 
@@ -60,23 +61,11 @@ void	CFXFallingTile::render()
 
 		if (!canRender()) return;
 
-u8			*PrimPtr=GetPrimPtr();
-POLY_FT3	*TPrimPtr=(POLY_FT3*)PrimPtr;
-sVtx		*P0,*P1,*P2;
-u32			T0,T1,T2;
-s32			ClipZ;
-sOT			*ThisOT;
-MATRIX		Mtx;
 DVECTOR		&RenderPos=getRenderPos();
-VECTOR		ThisRenderPos;
-
-			SetIdentNoTrans(&Mtx);
-
-			ThisRenderPos.vx=(INGAME_SCREENOFS_X)+RenderPos.vx;
-			ThisRenderPos.vy=(INGAME_SCREENOFS_Y)+RenderPos.vy;
 
 			u16			TileIdx=Tile>>2;
-			u16			Flip=Tile&3;
+			CModelGfx::RenderTile(RenderPos,TileIdx);
+/*			u16			Flip=Tile&3;
 			sFlipTable	*FTab=&FlipTable[Flip];
 			sElem3d		*Elem=&ElemBank3d[TileIdx];
 			int			TriCount=Elem->TriCount;				
@@ -114,5 +103,5 @@ VECTOR		ThisRenderPos;
 			}
 
 		SetPrimPtr((u8*)TPrimPtr);
-
+*/
 }

source/gfx/actor.cpp

@@ -769,42 +769,98 @@ u8		V=Node->V;
 /*****************************************************************************/
 /*****************************************************************************/
 sModel	*CModelGfx::ModelTable;
-sElem3d	*CModelGfx::ModelElemBank;
+sElem3d	*CModelGfx::ElemBank;
-sTri	*CModelGfx::ModelTriList;
+sTri	*CModelGfx::TriList;
-sQuad	*CModelGfx::ModelQuadList;
+sQuad	*CModelGfx::QuadList;
-sVtx	*CModelGfx::ModelVtxList;
+sVtx	*CModelGfx::VtxList;
+u16		*CModelGfx::VtxIdxList;
 
 /*****************************************************************************/
 void	CModelGfx::SetData(sLevelHdr *LevelHdr)
 {
 		ModelTable=LevelHdr->ModelList;
-		ModelElemBank=LevelHdr->ElemBank3d;
+		ElemBank=LevelHdr->ElemBank3d;
-		ModelTriList=LevelHdr->TriList;
+		TriList=LevelHdr->TriList;
-		ModelQuadList=LevelHdr->QuadList;
+		QuadList=LevelHdr->QuadList;
-		ModelVtxList=LevelHdr->VtxList;
+		VtxList=LevelHdr->VtxList;
+		VtxIdxList=LevelHdr->VtxIdxList;
 }
 
 /*****************************************************************************/
 void	CModelGfx::SetModel(int Type)
 {
 		Model=&CModelGfx::ModelTable[Type];
+		Elem=&ElemBank[Model->ElemID];
 }
 
 /*****************************************************************************/
-void		CModelGfx::Render(DVECTOR &Pos,SVECTOR *Angle,VECTOR *Scale,s32 ClipFlag)
+static const int	ElemXMin=-(16/2);
+static const int	ElemXMax=+(16/2);
+static const int	ElemYMin=-(16/2);
+static const int	ElemYMax=+(16/2);
+static const int	ElemZMin=-(16*4);
+static const int	ElemZMax=+(16*4);
+
+static VECTOR	VtxTable[8]=
+{
+	{ElemXMin,ElemYMin,ElemZMin},	// FLU
+	{ElemXMax,ElemYMin,ElemZMin},	// FRU
+	{ElemXMin,ElemYMax,ElemZMin},	// FLD
+	{ElemXMax,ElemYMax,ElemZMin},	// FRD
+
+	{ElemXMin,ElemYMin,ElemZMax},	// BLU
+	{ElemXMax,ElemYMin,ElemZMax},	// BRU
+	{ElemXMin,ElemYMax,ElemZMax},	// BLD
+	{ElemXMax,ElemYMax,ElemZMax},	// BRD
+};
+
+/*****************************************************************************/
+void	CModelGfx::RenderTile(DVECTOR &Pos,int TileID)
+{
+sElem3d	*ThisElem=&ElemBank[TileID];
+u32		*XYList=(u32*)SCRATCH_RAM;
+u32		*OutVtx=XYList;
+VECTOR	*V0,*V1,*V2,*InVtx=VtxTable;
+VECTOR	RenderPos;
+MATRIX	Mtx;
+
+		SetIdentNoTrans(&Mtx);
+		RenderPos.vx=(INGAME_SCREENOFS_X)+Pos.vx;
+		RenderPos.vy=(INGAME_SCREENOFS_Y)+Pos.vy;
+		gte_SetRotMatrix(&Mtx);
+		CMX_SetTransMtxXY(&RenderPos);
+
+		V0=InVtx++; 
+		V1=InVtx++; 
+		V2=InVtx++;
+		gte_ldv3(V0,V1,V2);
+		for (int i=0; i<(int)((sizeof(VtxTable)/sizeof(VECTOR))+1); i++)
+		{
+			u32	*OutPtr;
+			gte_rtpt(); // 22 cycles
+			V0=InVtx++;
+			V1=InVtx++;
+			V2=InVtx++;
+			gte_ldv3(V0,V1,V2);
+			OutPtr=OutVtx;
+			OutVtx+=3;
+			gte_stsxy3c(OutPtr);	// read XY back
+		}
+		XYList+=8;
+		RenderElem(ThisElem,Pos,0,0,0,XYList);
+}
+
+/*****************************************************************************/
+void		CModelGfx::RenderElem(sElem3d *ThisElem,DVECTOR &Pos,SVECTOR *Angle,VECTOR *Scale,s32 ClipFlag,u32 *TransBuffer)
 {
-#define	BLOCK_MULT	16
-sElem3d			*Elem=&ModelElemBank[Model->ElemID];
 u8				*PrimPtr=GetPrimPtr();
-POLY_FT3		*TPrimPtr=(POLY_FT3*)PrimPtr;
+u32				T0,T1,T2,T3;
-sVtx			*P0,*P1,*P2;
+u32				P0,P1,P2,P3;
-u32				T0,T1,T2;
 s32				ClipZ;
 sOT				*ThisOT;
 VECTOR			RenderPos;
-int				TriCount=Elem->TriCount;				
+MATRIX			Mtx;
-sTri			*TList=&ModelTriList[Elem->TriStart];
+u32	const		*XYList=(u32*)SCRATCH_RAM;
-				MATRIX	Mtx;
 
 // If has scale && angle then need to use PSX scale matrix, otherwise, force values
 			if (Angle)
@@ -833,34 +889,119 @@ sTri			*TList=&ModelTriList[Elem->TriStart];
 		gte_SetRotMatrix(&Mtx);
 		CMX_SetTransMtxXY(&RenderPos);
 
-		while (TriCount--)
+// --- Cache Vtx ----------
 		{
-			P0=&ModelVtxList[TList->P0]; P1=&ModelVtxList[TList->P1]; P2=&ModelVtxList[TList->P2];
+			int		Count=ThisElem->VtxTriCount;
-			gte_ldv3(P0,P1,P2);
+			sVtx	*V0,*V1,*V2;
-			setlen(TPrimPtr, GPU_PolyFT3Tag);
+			u16		*IdxTable=&VtxIdxList[ThisElem->VtxIdxStart];
-			TPrimPtr->code=TList->PolyCode;
+
-			gte_rtpt_b();
+			V0=&VtxList[*IdxTable++];
-			setShadeTex(TPrimPtr,1);
+			V1=&VtxList[*IdxTable++];
-			T0=*(u32*)&TList->uv0;		// Get UV0 & TPage
+			V2=&VtxList[*IdxTable++];
-			T1=*(u32*)&TList->uv1;		// Get UV1 & Clut
+			gte_ldv3(V0,V1,V2);
-			T2=*(u32*)&TList->uv2;		// Get UV2
+
-			*(u32*)&TPrimPtr->u0=T0;	// Set UV0
+			while (Count--)
-			*(u32*)&TPrimPtr->u1=T1;	// Set UV1
-			*(u32*)&TPrimPtr->u2=T2;	// Set UV2
-			ThisOT=OtPtr+TList->OTOfs;
-			TList++;
-			gte_nclip_b();
-			gte_stsxy3_ft3(TPrimPtr);
-			gte_stopz(&ClipZ);
-			ClipZ|=ClipFlag;		// <-- Evil!!
-			if (ClipZ<=0)
 			{
-				addPrim(ThisOT,TPrimPtr);
+				u32	*OutPtr;
-				TPrimPtr++;
+				gte_rtpt_b(); // 22 cycles
+		// Preload next (when able) - Must check this
+				V0=&VtxList[*IdxTable++];
+				V1=&VtxList[*IdxTable++];
+				V2=&VtxList[*IdxTable++];
+				OutPtr=TransBuffer;
+				TransBuffer+=3;
+				gte_ldv3(V0,V1,V2);
+				gte_stsxy3c(OutPtr);	// read XY back
 			}
 		}
 
-		SetPrimPtr((u8*)TPrimPtr);
+// --- Render Tri's -------------
+
+		int		TriCount=ThisElem->TriCount;
+		sTri	*TList=&TriList[ThisElem->TriStart];
+		while (TriCount--)
+		{
+			POLY_FT3	*ThisPrim=(POLY_FT3*)PrimPtr;
+
+			P0=XYList[TList->P0]; 
+			P1=XYList[TList->P1]; 
+			P2=XYList[TList->P2];
+			gte_ldsxy0(P0);
+			gte_ldsxy1(P1);
+			gte_ldsxy2(P2);
+
+			setlen(ThisPrim, GPU_PolyFT3Tag);
+			ThisPrim->code=TList->PolyCode;
+			gte_nclip_b();	// 8 cycles
+
+			setShadeTex(ThisPrim,1);
+
+			T0=*(u32*)&TList->uv0;		// Get UV0 & TPage
+			T1=*(u32*)&TList->uv1;		// Get UV1 & Clut
+			T2=*(u32*)&TList->uv2;		// Get UV2
+			*(u32*)&ThisPrim->u0=T0;	// Set UV0
+			*(u32*)&ThisPrim->u1=T1;	// Set UV1
+			*(u32*)&ThisPrim->u2=T2;	// Set UV2
+
+			gte_stopz(&ClipZ);
+			ThisOT=OtPtr+TList->OTOfs;
+			ClipZ|=ClipFlag;			// <-- Evil!!
+			TList++;
+			if (ClipZ<0)
+			{
+				*(u32*)&ThisPrim->x0=P0;	// Set XY0
+				*(u32*)&ThisPrim->x1=P1;	// Set XY1
+				*(u32*)&ThisPrim->x2=P2;	// Set XY2
+				addPrim(ThisOT,ThisPrim);
+				PrimPtr+=sizeof(POLY_FT3);
+			}
+		}
+
+// --- Render Quads -----------
+		int		QuadCount=ThisElem->QuadCount;
+		sQuad	*QList=&QuadList[ThisElem->QuadStart];
+		while (QuadCount--)
+		{
+			POLY_FT4	*ThisPrim=(POLY_FT4*)PrimPtr;
+
+			P0=XYList[QList->P0]; 
+			P1=XYList[QList->P1]; 
+			P2=XYList[QList->P2];
+			P3=XYList[QList->P3];
+			gte_ldsxy0(P0);
+			gte_ldsxy1(P1);
+			gte_ldsxy2(P2);
+			
+			setlen(ThisPrim, GPU_PolyFT4Tag);
+			ThisPrim->code=QList->PolyCode;
+			gte_nclip_b();	// 8 cycles
+
+			setShadeTex(ThisPrim,1);
+
+			T0=*(u32*)&QList->uv0;		// Get UV0 & TPage
+			T1=*(u32*)&QList->uv1;		// Get UV1 & Clut
+			T2=*(u32*)&QList->uv2;		// Get UV2
+			T3=*(u32*)&QList->uv3;		// Get UV2
+			*(u32*)&ThisPrim->u0=T0;	// Set UV0
+			*(u32*)&ThisPrim->u1=T1;	// Set UV1
+			*(u32*)&ThisPrim->u2=T2;	// Set UV2
+			*(u32*)&ThisPrim->u3=T3;	// Set UV2
+			gte_stopz(&ClipZ);
+			ThisOT=OtPtr+QList->OTOfs;
+			ClipZ|=ClipFlag;			// <-- Evil!!
+			QList++;
+			if (ClipZ<0)
+			{
+				*(u32*)&ThisPrim->x0=P0;	// Set XY0
+				*(u32*)&ThisPrim->x1=P1;	// Set XY1
+				*(u32*)&ThisPrim->x2=P2;	// Set XY2
+				*(u32*)&ThisPrim->x3=P3;	// Set XY3
+				addPrim(ThisOT,ThisPrim);
+				PrimPtr+=sizeof(POLY_FT4);
+			}
+		}
+
+		SetPrimPtr(PrimPtr);
 
 }
 

source/gfx/actor.h

@@ -170,19 +170,28 @@ virtual	~CModelGfx(){};
 static	void		SetData(sLevelHdr *LevelHdr);
 		void		SetModel(int Type);
 
-		void		Render(DVECTOR &Pos,SVECTOR *Angle=0,VECTOR *Scale=0,s32 ClipFlag=0xffffffff);
+static	void		RenderTile(DVECTOR &Pos,int TileID);
+static	void		RenderElem(sElem3d *Elem,DVECTOR &Pos,SVECTOR *Angle=0,VECTOR *Scale=0,s32 ClipFlag=0xffffffff,u32 *TransBuffer=(u32*)SCRATCH_RAM);
+
+		void		Render(DVECTOR &Pos,SVECTOR *Angle=0,VECTOR *Scale=0,s32 ClipFlag=0xffffffff) {RenderElem(Elem,Pos,Angle,Scale,ClipFlag);}
 		void		RenderClip(DVECTOR &Pos,SVECTOR *Angle=0,VECTOR *Scale=0)	{Render(Pos,Angle,Scale,0);}
+
 		sBBox		&GetBBox()		{return(Model->BBox);}
 
 protected:
+		void		CacheModelVtx();
 
 static	sModel		*ModelTable;
-static	sElem3d		*ModelElemBank;
+static	sElem3d		*ElemBank;
-static	sTri		*ModelTriList;
+static	sTri		*TriList;
-static	sQuad		*ModelQuadList;
+static	sQuad		*QuadList;
-static	sVtx		*ModelVtxList;
+static	sVtx		*VtxList;
+static	u16			*VtxIdxList;
+
 
 		sModel		*Model;
+		sElem3d		*Elem;
+
 };
 
 /*****************************************************************************/

source/level/layertile3d.cpp

@@ -317,7 +317,37 @@ s16				TCount=0,QCount=0;
 					CMX_SetTransMtxXY(&BlkPos);
 					CMX_SetRotMatrixXY(&FTab->Mtx);
 
-					CacheElemVtx(Elem);
+// --- Cache Vtx ----------
+//					CacheElemVtx(Elem);
+					{
+					int		Count=Elem->VtxTriCount;
+					sVtx	*V0,*V1,*V2;
+					u16		*IdxTable=&VtxIdxList[Elem->VtxIdxStart];
+					s32		*OutVtx=(s32*)SCRATCH_RAM;
+					s32		*OutPtr;
+
+							OutVtx+=8;
+
+							V0=&VtxList[*IdxTable++];
+							V1=&VtxList[*IdxTable++];
+							V2=&VtxList[*IdxTable++];
+							gte_ldv3(V0,V1,V2);
+
+							while (Count--)
+							{
+								gte_rtpt_b(); // 22 cycles
+					// Preload next (when able) - Must check this
+								V0=&VtxList[*IdxTable++];
+								V1=&VtxList[*IdxTable++];
+								V2=&VtxList[*IdxTable++];
+								OutPtr=OutVtx;
+								OutVtx+=3;
+								gte_ldv3(V0,V1,V2);
+								gte_stsxy3c(OutPtr);	// read XY back
+							}
+
+					}
+
 
 					s16	FL=DeltaFX[0]+DeltaFOfs.vx;
 					s16	FR=DeltaFX[1]+DeltaFOfs.vx;
@@ -353,6 +383,7 @@ s16				TCount=0,QCount=0;
 					DP3->vx=BR;
 					DP3->vy=BD;
 
+// --- Render Tri's -------------
 					while (TriCount--)
 					{
 						POLY_FT3	*ThisPrim=(POLY_FT3*)PrimPtr;
@@ -396,6 +427,8 @@ s16				TCount=0,QCount=0;
 
 						}
 					}
+
+// --- Render Quads -----------
 					while (QuadCount--)
 					{
 						POLY_FT4	*ThisPrim=(POLY_FT4*)PrimPtr;