zydronium/SBSPSS
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Browse source
This commit is contained in:
Daveo 2001-01-04 21:53:14 +00:00
parent 5c55823d63
commit e2956c44ee
12 changed files with 277 additions and 203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Utils/MapEdit/TileSet.cpp
View file

@ -346,6 +346,7 @@ BOOL CTileBank::SelectCancel()
BOOL CTileBank::IsTileValid(int Set,int Tile)
{
if (Set<0 || Tile<0) return(FALSE);
if (Tile==0) return(TRUE);
ASSERT(Set<TileSet.size());
return(TileSet[Set].IsTileValid(Tile));

18
source/gfx/prim.cpp
View file

@ -10,23 +10,11 @@
/*****************************************************************************/
sOT *OtList[2],*OtPtr;
u32 *PrimDrawList;
u32 DmaStart[2];
u8 *PrimBuffer[2],*PrimListStart,*PrimListEnd;
u8 *CurrPrim,*EndPrim;
int PrimFlipFlag;
/*****************************************************************************/
void PrimDrawCallBack()
{
if (PrimDrawList)
{
DrawOTag2(PrimDrawList);
}
PrimDrawList=0;
}
/*****************************************************************************/
void PrimInit()
{
@ -47,7 +35,6 @@ void PrimInit()
InitOTagR(OtList[0],MAX_OT);
InitOTagR(OtList[1],MAX_OT);
PrimDrawList=0;
}
@ -58,10 +45,9 @@ void PrimDisplay()
UnlinkOTagR(OtPtr, MAX_OT, &DmaStart[PrimFlipFlag]);
#ifdef USE_NTAGS
// DrawOTag((u32*)&DmaStart[PrimFlipFlag]);
PrimDrawList=&DmaStart[PrimFlipFlag];
DrawOTag((u32*)&DmaStart[PrimFlipFlag]);
#else
// DrawOTag(OtPtr+(MAX_OT-1));
DrawOTag(OtPtr+(MAX_OT-1));
#endif
PrimFlipFlag^=1;

1
source/gfx/prim.h
View file

@ -306,7 +306,6 @@ extern u8 *PrimListStart,*PrimListEnd;
void PrimInit();
void PrimDisplay();
void PrimDrawCallBack();
void PrimClip(RECT *r, u32 Depth);
void PrimFullScreen(int Depth);

160
source/level/layertile.cpp
View file

@ -64,7 +64,7 @@ int Size=Width*Height;
// Tile prim
setTSprt16(&ThisElem->Prim);
setTSetShadeTex(&ThisElem->Prim,1);
// Table
// Grid
ThisElem->Right=GetGridPos(X+1,Y);
ThisElem->Down=GetGridPos(X,Y+1);
}
@ -73,7 +73,7 @@ int Size=Width*Height;
}
/*****************************************************************************/
// AS not critical, us row update routine for whole map
// AS not time critical, use row update routine for whole map
void CLayerTile::UpdateWholeMap()
{
for (int Y=0; Y<PrimGridHeight; Y++)
@ -92,26 +92,28 @@ void CLayerTile::shutdown()
// Get (wrapped) PrimGrid pos
sPrimGridElem *CLayerTile::GetGridPos(int X,int Y)
{
sPrimGridElem *ThisGrid=(sPrimGridElem *)PrimGrid;
int Pos;
/**/ X%=PrimGridWidth;
/**/ Y%=PrimGridHeight;
/**/ Pos=(X+(Y*PrimGridWidth));
/**/ return(PrimGrid+Pos);
/**/ return(ThisGrid+Pos);
}
/*****************************************************************************/
// Get (wrapped) Map pos
sTileMapElem *CLayerTile::GetMapPos(int X,int Y)
{
sTileMapElem *ThisMap=(sTileMapElem *)Map;
int Pos;
/**/ X%=MapWidth;
/**/ Y%=MapHeight;
/**/ Pos=(X+(Y*MapWidth));
/**/ return(Map+Pos);
/**/ return(ThisMap+Pos);
}
@ -158,21 +160,19 @@ int NewY=YPos>>4;
/*****************************************************************************/
void CLayerTile::UpdateRow(int X,int Y)
{
sPrimGridElem *Table=GetGridPos(X,Y);
sPrimGridElem *Grid=GetGridPos(X,Y);
sTileMapElem *MapPtr=GetMapPos(X,Y);
for (int i=0; i<SCREEN_TILE_WIDTH; i++)
{
// Tile prim
TSPRT_16 *Prim=&Table->Prim;
TSPRT_16 *Prim=&Grid->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
/**/ Table->Tile=MapPtr->Tile;
/**/ Table->Flags=MapPtr->Flags;
// Next Elem
MapPtr++;
Table=Table->Right;
Grid=Grid->Right;
}
}
@ -180,21 +180,19 @@ sTileMapElem *MapPtr=GetMapPos(X,Y);
/*****************************************************************************/
void CLayerTile::UpdateColumn(int X,int Y)
{
sPrimGridElem *Table=GetGridPos(X,Y);
sPrimGridElem *Grid=GetGridPos(X,Y);
sTileMapElem *MapPtr=GetMapPos(X,Y);
for (int i=0; i<SCREEN_TILE_HEIGHT; i++)
{
// Tile prim
TSPRT_16 *Prim=&Table->Prim;
TSPRT_16 *Prim=&Grid->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
/**/ Table->Tile=MapPtr->Tile;
/**/ Table->Flags=MapPtr->Flags;
// Next Elem
MapPtr+=MapWidth;
Table=Table->Down;
Grid=Grid->Down;
}
}
@ -203,7 +201,7 @@ sTileMapElem *MapPtr=GetMapPos(X,Y);
/*****************************************************************************/
void CLayerTile::render()
{
sPrimGridElem *Table=GetGridPos(MapX,MapY);
sPrimGridElem *Grid=GetGridPos(MapX,MapY);
s16 TileX,TileY;
// Setup shift bits of pos
@ -212,147 +210,23 @@ s16 TileX,TileY;
// Render it!!
for (int Y=0; Y<SCREEN_TILE_HEIGHT; Y++)
{
sPrimGridElem *TableDown=Table->Down;
sPrimGridElem *GridDown=Grid->Down;
TileX=-ShiftX;
for (int X=0; X<SCREEN_TILE_WIDTH; X++)
{
TSPRT_16 *Prim=&Table->Prim;
TSPRT_16 *Prim=&Grid->Prim;
if (Prim->clut)
{
/**/ Prim->x0=TileX;
/**/ Prim->y0=TileY;
/**/ AddPrim(OtPtr,Prim);
}
Table=Table->Right;
Grid=Grid->Right;
TileX+=TILE_WIDTH;
}
Table=TableDown;
Grid=GridDown;
TileY+=TILE_HEIGHT;
}
}
/*****************************************************************************/
void CLayerTile::renderSolid()
{
sPrimGridElem *Table=GetGridPos(MapX,MapY);
s16 TileX,TileY;
// Setup shift bits of pos
TileY=-ShiftY;
// Render it!!
for (int Y=0; Y<SCREEN_TILE_HEIGHT; Y++)
{
sPrimGridElem *TableDown=Table->Down;
TileX=-ShiftX;
for (int X=0; X<SCREEN_TILE_WIDTH; X++)
{
TSPRT_16 *Prim=&Table->Prim;
/**/ Prim->x0=TileX;
/**/ Prim->y0=TileY;
/**/ AddPrim(OtPtr,Prim);
Table=Table->Right;
TileX+=TILE_WIDTH;
}
Table=TableDown;
TileY+=TILE_HEIGHT;
}
}
/*****************************************************************************/
#define BLOCK_MULT 16
void CLayerTile::render3d()
{
sPrimGridElem *Table=GetGridPos(MapX,MapY);
s16 TileX,TileY;
VECTOR BlkPos;
s32 BlkXStore;
// Setup shift bits of pos
TileY=-ShiftY;
BlkPos.vx=((-15*TILE_WIDTH)-ShiftX)*BLOCK_MULT;
BlkPos.vy=((-8*TILE_HEIGHT)-ShiftY)*BLOCK_MULT;
BlkXStore=BlkPos.vx;
// Render it!!
for (int Y=0; Y<SCREEN_TILE_HEIGHT; Y++)
{
sPrimGridElem *TableDown=Table->Down;
TileX=-ShiftX;
for (int X=0; X<SCREEN_TILE_WIDTH; X++)
{
TSPRT_16 *Prim=&Table->Prim;
if (Prim->clut)
{ // Has 2d Data
/**/ Prim->x0=TileX;
/**/ Prim->y0=TileY;
/**/ AddPrim(OtPtr,Prim);
}
if (Table->Flags)
{ // Has 3d Data
/**/ CMX_SetTransMtxXY(&BlkPos);
/**/ RenderBlock(Table);
}
Table=Table->Right;
TileX+=TILE_WIDTH;
BlkPos.vx+=TILE_WIDTH*BLOCK_MULT;
}
Table=TableDown;
TileY+=TILE_HEIGHT;
BlkPos.vx=BlkXStore;
BlkPos.vy+=TILE_HEIGHT*BLOCK_MULT;
}
}
/*****************************************************************************/
// NOTE: Tiles will be sorted by z order (cos they 'should' be simple objects
// NOTE: Tiles are split into facing strips, to reduce overdraw :o)
// NOTE: Matrix already setup for block
void CLayerTile::RenderBlock(sPrimGridElem *Elem)
{
sTile *Tile=&TileList[Elem->Tile];
u32 Flags=Elem->Flags;
sVtx *P0,*P1,*P2;
POLY_FT3 *TPrimPtr=(POLY_FT3*)GetPrimPtr();
sTileTable *TileTable=Tile->TileTable;
u32 T0,T1,T2;
//--- Tris ---------------------------------------------------------------------------
for (int i=0; i<TILE3D_FLAGS_MAX; i++)
{
int TriCount=TileTable->TriCount;
sTri *TList=TriList+TileTable->TriList;
if (Flags & 1)
{
while (TriCount--)
{
P0=&VtxList[TList->P0]; P1=&VtxList[TList->P1]; P2=&VtxList[TList->P2];
gte_ldv3(P0,P1,P2);
/**/ setPolyFT3(TPrimPtr);
/**/ setShadeTex(TPrimPtr,1);
/**/ setlen(TPrimPtr, GPU_PolyFT3Tag);
gte_rtpt_b();
T0=*(u32*)&TList->uv0; // Get UV0 & TPage
T1=*(u32*)&TList->uv1; // Get UV1 & Clut
T2=*(u16*)&TList->uv2; // Get UV2
*(u32*)&TPrimPtr->u0=T0; // Set UV0
*(u32*)&TPrimPtr->u1=T1; // Set UV1
*(u16*)&TPrimPtr->u2=T2; // Set UV2
TList++;
addPrim(OtPtr,TPrimPtr);
gte_stsxy3_ft3(TPrimPtr);
TPrimPtr++;
}
}
TileTable++;
Flags>>=1;
}
SetPrimPtr((u8*)TPrimPtr);
}

35
source/level/layertile.h
View file

@ -7,14 +7,30 @@
/*****************************************************************************/
/*
struct sPrimGridElem
{
TSPRT_16 Prim;
u16 Tile;
u16 Flags;
// u16 Tile;
// u16 Flags;
sPrimGridElem *Right;
sPrimGridElem *Down;
};
*/
/*****************************************************************************/
struct sPrimGridElem
{
TSPRT_16 Prim;
sPrimGridElem *Right;
sPrimGridElem *Down;
};
struct sPrimGridElem3d : public sPrimGridElem
{
u16 Tile;
u16 Flags;
};
/*****************************************************************************/
class CLayerTile
@ -47,30 +63,27 @@ virtual void shutdown();
virtual void think(VECTOR &MapPos);
virtual void render();
protected:
void UpdateWholeMap();
virtual void UpdateWholeMap();
virtual void UpdateRow(int MapX,int MapY);
virtual void UpdateColumn(int MapX,int MapY);
sPrimGridElem *GetGridPos(int X,int Y);
sTileMapElem *GetMapPos(int X,int Y);
void UpdateRow(int MapX,int MapY);
void UpdateColumn(int MapX,int MapY);
void renderSolid();
void render3d();
void RenderBlock(sPrimGridElem *Elem);
sLayerHdr *LayerHdr;
sTile *TileList;
sTri *TriList;
sQuad *QuadList;
sVtx *VtxList;
sTileMapElem *Map;
int MapWidth,MapHeight,MapXYShift;
int PrimGridWidth,PrimGridHeight;
int MapX,MapY;
u16 ShiftX,ShiftY;
sTileMapElem *Map;
sPrimGridElem *PrimGrid;
};

204
source/level/layertile3d.cpp
View file

@ -30,7 +30,34 @@ CLayerTile3d::~CLayerTile3d()
/*****************************************************************************/
void CLayerTile3d::init(VECTOR &MapPos,int Shift,int Width,int Height)
{
CLayerTile::init(MapPos,Shift);
int Size=Width*Height;
ASSERT(Width>=SCREEN_TILE_WIDTH);
ASSERT(Height>=SCREEN_TILE_HEIGHT);
MapXYShift=Shift;
PrimGridWidth=Width;
PrimGridHeight=Height;
PrimGrid=(sPrimGridElem3d*) MemAlloc(Size*sizeof(sPrimGridElem3d),"3d PrimGrid");
ASSERT(PrimGrid);
MapX=0;
MapY=0;
for (int Y=0; Y<PrimGridHeight; Y++)
{
for (int X=0; X<PrimGridWidth; X++)
{
sPrimGridElem3d *ThisElem=GetGridPos3d(X,Y);
// Tile prim
setTSprt16(&ThisElem->Prim);
setTSetShadeTex(&ThisElem->Prim,1);
// Table
ThisElem->Right=GetGridPos3d(X+1,Y);
ThisElem->Down=GetGridPos3d(X,Y+1);
}
}
UpdateWholeMap();
}
/*****************************************************************************/
@ -39,8 +66,179 @@ void CLayerTile3d::shutdown()
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
// Get (wrapped) PrimGrid pos
sPrimGridElem3d *CLayerTile3d::GetGridPos3d(int X,int Y)
{
sPrimGridElem3d *ThisGrid=(sPrimGridElem3d*)PrimGrid;
int Pos;
/**/ X%=PrimGridWidth;
/**/ Y%=PrimGridHeight;
/**/ Pos=(X+(Y*PrimGridWidth));
/**/ return(ThisGrid+Pos);
}
/*****************************************************************************/
// Get (wrapped) Map pos
sTileMapElem3d *CLayerTile3d::GetMapPos3d(int X,int Y)
{
sTileMapElem3d *ThisMap=(sTileMapElem3d*)Map;
int Pos;
/**/ X%=MapWidth;
/**/ Y%=MapHeight;
/**/ Pos=(X+(Y*MapWidth));
/**/ return(ThisMap+Pos);
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CLayerTile3d::UpdateRow(int X,int Y)
{
sPrimGridElem3d *Grid=GetGridPos3d(X,Y);
sTileMapElem3d *MapPtr=GetMapPos3d(X,Y);
for (int i=0; i<SCREEN_TILE_WIDTH; i++)
{
// Tile prim
TSPRT_16 *Prim=&Grid->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
/**/ Grid->Tile=MapPtr->Tile;
/**/ Grid->Flags=MapPtr->Flags;
// Next Elem
MapPtr++;
Grid=(sPrimGridElem3d *)Grid->Right;
}
}
/*****************************************************************************/
void CLayerTile3d::UpdateColumn(int X,int Y)
{
sPrimGridElem3d *Grid=GetGridPos3d(X,Y);
sTileMapElem3d *MapPtr=GetMapPos3d(X,Y);
for (int i=0; i<SCREEN_TILE_HEIGHT; i++)
{
// Tile prim
TSPRT_16 *Prim=&Grid->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
/**/ Grid->Tile=MapPtr->Tile;
/**/ Grid->Flags=MapPtr->Flags;
// Next Elem
MapPtr+=MapWidth;
Grid=(sPrimGridElem3d *)Grid->Down;
}
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
#define BLOCK_MULT 16
void CLayerTile3d::render()
{
// CLayerTile::render();
CLayerTile::render3d();
sPrimGridElem3d *Grid=GetGridPos3d(MapX,MapY);
s16 TileX,TileY;
VECTOR BlkPos;
s32 BlkXStore;
// Setup shift bits of pos
TileY=-ShiftY;
BlkPos.vx=((-15*TILE_WIDTH)-ShiftX)*BLOCK_MULT;
BlkPos.vy=((-8*TILE_HEIGHT)-ShiftY)*BLOCK_MULT;
BlkXStore=BlkPos.vx;
// Render it!!
for (int Y=0; Y<SCREEN_TILE_HEIGHT; Y++)
{
sPrimGridElem *GridDown=(sPrimGridElem3d *)Grid->Down;
TileX=-ShiftX;
for (int X=0; X<SCREEN_TILE_WIDTH; X++)
{
TSPRT_16 *Prim=&Grid->Prim;
if (Prim->clut)
{ // Has 2d Data
/**/ Prim->x0=TileX;
/**/ Prim->y0=TileY;
/**/ AddPrim(OtPtr,Prim);
}
if (Grid->Flags)
{ // Has 3d Data
/**/ CMX_SetTransMtxXY(&BlkPos);
/**/ RenderBlock(Grid);
}
Grid=(sPrimGridElem3d *)Grid->Right;
TileX+=TILE_WIDTH;
BlkPos.vx+=TILE_WIDTH*BLOCK_MULT;
}
Grid=(sPrimGridElem3d *)GridDown;
TileY+=TILE_HEIGHT;
BlkPos.vx=BlkXStore;
BlkPos.vy+=TILE_HEIGHT*BLOCK_MULT;
}
}
/*****************************************************************************/
// NOTE: Tiles will be sorted by z order (cos they 'should' be simple objects
// NOTE: Tiles are split into facing strips, to reduce overdraw :o)
// NOTE: Matrix already setup for block
void CLayerTile3d::RenderBlock(sPrimGridElem3d *Elem)
{
sTile *Tile=&TileList[Elem->Tile];
u32 Flags=Elem->Flags;
sVtx *P0,*P1,*P2;
POLY_FT3 *TPrimPtr=(POLY_FT3*)GetPrimPtr();
u16 *TileTable=Tile->TileTable;
u32 T0,T1,T2;
sTri *TList=TriList+Tile->TriStart;
//--- Tris ---------------------------------------------------------------------------
for (int i=0; i<TILE3D_FLAGS_MAX; i++)
{
int TriCount=*TileTable++; // Get Tri Count
sTri *NextList=TList+TriCount;
if (Flags & 1)
{
while (TriCount--)
{
P0=&VtxList[TList->P0]; P1=&VtxList[TList->P1]; P2=&VtxList[TList->P2];
gte_ldv3(P0,P1,P2);
/**/ setPolyFT3(TPrimPtr);
/**/ setShadeTex(TPrimPtr,1);
/**/ setlen(TPrimPtr, GPU_PolyFT3Tag);
gte_rtpt_b();
T0=*(u32*)&TList->uv0; // Get UV0 & TPage
T1=*(u32*)&TList->uv1; // Get UV1 & Clut
T2=*(u16*)&TList->uv2; // Get UV2
*(u32*)&TPrimPtr->u0=T0; // Set UV0
*(u32*)&TPrimPtr->u1=T1; // Set UV1
*(u16*)&TPrimPtr->u2=T2; // Set UV2
TList++;
addPrim(OtPtr,TPrimPtr);
gte_stsxy3_ft3(TPrimPtr);
TPrimPtr++;
}
}
TList=NextList;
Flags>>=1;
}
SetPrimPtr((u8*)TPrimPtr);
}

7
source/level/layertile3d.h
View file

@ -18,6 +18,13 @@ public:
void render();
protected:
void UpdateRow(int MapX,int MapY);
void UpdateColumn(int MapX,int MapY);
sPrimGridElem3d *GetGridPos3d(int X,int Y);
sTileMapElem3d *GetMapPos3d(int X,int Y);
void RenderBlock(sPrimGridElem3d *Elem);
};

3
source/system/main.cpp
View file

@ -146,7 +146,6 @@ void MainLoop()
#ifdef __USER_paul__
s_paulScene.think(frames);
#endif
while(DrawSync(1));
// Render States
@ -159,8 +158,8 @@ void MainLoop()
#endif
PrimDisplay();
VidSwapDraw();
VSync(0);
VidSwapDraw();
PadUpdate();

2
source/system/vid.cpp
View file

@ -144,8 +144,6 @@ static void VidVSyncCallback()
TickCount++;
if (DrawLoadIcon) LoadingIcon();
PrimDrawCallBack();
if (VbFunc)
{
VbFunc();

BIN
tools/Data/bin/MkLevel.exe
View file

Binary file not shown.

41
tools/Data/include/dstructs.h
View file

@ -93,29 +93,21 @@ struct sTri
u16 P2; // 2
}; // 16
// u8 r0, g0, b0, code; // 4
// u8 r1, g1, b1, Mat; // 4
// u8 r2, g2, b2; // 3
// s8 OtOfs; // 1
//---------------------------------------------------------------------------
struct sQuad
{
u16 P0,P1,P2,P3; // 8
u16 P0; // 2
u16 P1; // 2
u16 P2; // 2
u16 P3; // 2
u8 uv0[2]; // 2
u16 Clut; // 2
u8 uv1[2]; // 2
u16 TPage; // 2
u8 uv2[2]; // 2
u8 uv3[2]; // 2
u16 TPage; // 2
u16 Clut; // 2
}; // 20
// u8 r0, g0, b0, code; // 4
// u8 r1, g1, b1, Mat; // 4
// u8 r2, g2, b2; // 3
// s8 OtOfs; // 1
// u8 r3, g3, b3, Pad3; // 4
//***************************************************************************
/*
struct sWeight
@ -152,29 +144,36 @@ enum TILE3D_FLAGS
struct sTileMapElem
{
u16 Tile;
};
struct sTileMapElem3d : public sTileMapElem
{
u16 Flags;
};
/*
struct sTileTable
{
u16 TriList;
u16 TriCount;
};
*/
struct sTile
{
// 3d Tile
sTileTable TileTable[TILE3D_FLAGS_MAX];
// sTileTable TileTable[TILE3D_FLAGS_MAX]; // 20 (4*5)
u16 TriStart; // 2
u16 TileTable[TILE3D_FLAGS_MAX]; // 10
// 2d Tile
u8 u0,v0;
u16 Clut;
u16 TPage;
u16 Pad; // :o( need this?
u8 u0,v0; // 2
u16 Clut; // 2
u16 TPage; // 2
u16 Pad; // :o( need this? // 2
#ifdef WIN32
bool operator==(sTile const &v1) {return(false);}
#endif
};
}; // 20
//---------------------------------------------------------------------------
// Layers