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

Browse source
This commit is contained in:
Daveo 2000-12-12 20:56:51 +00:00
parent 70840d8bc3
commit 8951f10167
9 changed files with 354 additions and 144 deletions
Download patch file Download diff file Expand all files Collapse all files

212
source/level/layertile.cpp
View file

@ -10,6 +10,9 @@
#include "LayerTile.h"
const u32 XInc=16<<0;
const u32 YInc=16<<16;
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
@ -31,9 +34,17 @@ CLayerTile::~CLayerTile()
if (TileMap2d[1].List) MemFree(TileMap2d[1].List);
}
/*****************************************************************************/
sTileMap2d &CLayerTile::GetTileMap()
{
return(TileMap2d[FrameFlipFlag]);
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
// NEED TO UPDATE FOR DIFF MAP POS's
void CLayerTile::InitTileMap2d(int InitX,int InitY,int Width,int Height)
void CLayerTile::init(VECTOR &MapPos,int Shift,int Width,int Height)
{
int Size=Width*Height;
int MapWidth=GetWidth();
@ -42,19 +53,23 @@ int MapHeight=GetWidth();
ASSERT(Width>=SCREEN_TILE_WIDTH);
ASSERT(Height>=SCREEN_TILE_HEIGHT);
MapShift=Shift;
TileMapWidth=Width;
TileMapHeight=Height;
for (int Buffer=0; Buffer<2; Buffer++)
{
sTileMapElem *MapPtr=Map;
sTileMap2dElem *List=(sTileMap2dElem*) MemAlloc(Size*sizeof(sTileMap2dElem),"2d TileMap");
TileMap2d[Buffer].List=List;
TileMap2d[Buffer].MapX=0;
TileMap2d[Buffer].MapY=0;
for (int Y=0; Y<Height; Y++)
{
for (int X=0; X<Width; X++)
{
sTileMapElem *MapPtr=&Map[X+(Y*MapWidth)];
sTileMap2dElem *ThisElem=&List[X+(Y*Width)];
// Tile prim
TSPRT_16 *ThisTile=&ThisElem->Tile;
@ -67,6 +82,8 @@ int MapHeight=GetWidth();
ThisTile->clut=SrcTile->Clut;
ThisTile->u0=SrcTile->uv0[0];
ThisTile->v0=SrcTile->uv0[1];
if (!MapPtr->Tile)
ThisTile->clut=0;
// Table
int TableR=(X+1) % Width;
@ -74,7 +91,7 @@ int MapHeight=GetWidth();
ThisElem->Right=&List[TableR+(Y*Width)];
ThisElem->Down=&List[X+(TableD*Width)];
MapPtr++;
// MapPtr++;
}
}
@ -83,27 +100,147 @@ int MapHeight=GetWidth();
}
/*****************************************************************************/
void CLayerTile::RenderTileMap2d(int MapX,int MapY)
void CLayerTile::shutdown()
{
sTileMap2dElem *Table=TileMap2d[FrameFlipFlag].List;
int XShift,YShift;
}
/*****************************************************************************/
int CLayerTile::CalcTableOfs(int X,int Y)
{
/**/ X%=TileMapWidth;
/**/ Y%=TileMapHeight;
/**/ return(X+(Y*TileMapWidth));
}
/*****************************************************************************/
int CLayerTile::CalcMapOfs(int X,int Y)
{
int MapWidth=GetWidth();
int MapHeight=GetHeight();
/**/ X%=MapWidth;
/**/ Y%=MapHeight;
/**/ return(X+(Y*MapWidth));
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CLayerTile::think(VECTOR &MapPos)
{
// Update rows and Columns :o)
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag];
int XPos=MapPos.vx>>MapShift;
int YPos=MapPos.vy>>MapShift;
int ShiftX=15-(XPos&15);
int ShiftY=15-(YPos&15);
ThisTable.ShiftXY=ShiftY<<16 | ShiftX<<0;
int NewX=XPos>>4;
int NewY=YPos>>4;
int OldX=ThisTable.MapX;
int OldY=ThisTable.MapY;
if (NewX>OldX)
{ // update right column
UpdateColumn(NewX+SCREEN_TILE_WIDTH-1,NewY,ThisTable);
}
else
if (NewX<OldX)
{ // update left column
UpdateColumn(NewX,NewY,ThisTable);
}
if (NewY>OldY)
{ // update bottom row
UpdateRow(NewX,NewY+SCREEN_TILE_HEIGHT-1,ThisTable);
}
else
if (NewY<OldY)
{ // update top row
UpdateRow(NewX,NewY,ThisTable);
}
ThisTable.MapX=NewX;
ThisTable.MapY=NewY;
}
/*****************************************************************************/
void CLayerTile::UpdateRow(int MapX,int MapY,sTileMap2d &ThisTable)
{
sTileMap2dElem *Table=ThisTable.List;
sTileMapElem *MapPtr=Map;
//int MapWidth=GetWidth();
// Calc (wrapped) Map/Table pos
Table+=CalcTableOfs(MapX,MapY);
MapPtr+=CalcMapOfs(MapX,MapY);
for (int i=0; i<SCREEN_TILE_WIDTH-1; i++)
{
// Tile prim
TSPRT_16 *ThisTile=&Table->Tile;
sTile *SrcTile=&TileList[MapPtr->Tile];
setTSprtTPage(ThisTile,SrcTile->TPage);
ThisTile->clut=SrcTile->Clut;
ThisTile->u0=SrcTile->uv0[0];
ThisTile->v0=SrcTile->uv0[1];
MapPtr+=1;
Table=Table->Right;
}
}
/*****************************************************************************/
// As column is smaller than row, it takes the corner tiles on, to balance the flow
void CLayerTile::UpdateColumn(int MapX,int MapY,sTileMap2d &ThisTable)
{
sTileMap2dElem *Table=ThisTable.List;
sTileMapElem *MapPtr=Map;
int MapWidth=GetWidth();
// Calc (wrapped) Map/Table pos
Table+=CalcTableOfs(MapX,MapY);
MapPtr+=CalcMapOfs(MapX,MapY);
for (int i=0; i<SCREEN_TILE_HEIGHT; i++)
{
// Tile prim
TSPRT_16 *ThisTile=&Table->Tile;
sTile *SrcTile=&TileList[MapPtr->Tile];
setTSprtTPage(ThisTile,SrcTile->TPage);
ThisTile->clut=SrcTile->Clut;
ThisTile->u0=SrcTile->uv0[0];
ThisTile->v0=SrcTile->uv0[1];
MapPtr+=MapWidth;
Table=Table->Down;
}
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CLayerTile::render()
{
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag];
sTileMap2dElem *Table=ThisTable.List;
u32 XYPos;
const u32 XInc=16<<0;
const u32 YInc=16<<16;
// Setup shift bits of pos
XShift=15-(MapX&15);
YShift=15-(MapY&15);
XYPos=YShift<<16 | XShift<<0;
XYPos=ThisTable.ShiftXY;
MapX>>=4;
MapY>>=4;
// Calc (wrapped) Start pos
/**/ MapX=MapX % TileMapWidth;
/**/ MapY=MapY % TileMapHeight;
/**/ Table+=MapX;
/**/ Table+=MapY*TileMapWidth;
Table+=CalcTableOfs(ThisTable.MapX,ThisTable.MapY);
// Render it!!
for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++)
@ -112,9 +249,12 @@ const u32 YInc=16<<16;
u32 XYPosDown=XYPos+YInc;
for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++)
{
TSPRT_16 *TileData=&Table->Tile;
*(u32*)&TileData->x0=XYPos;
/**/ AddPrim(OtPtr,TileData);
TSPRT_16 *Tile=&Table->Tile;
if (Tile->clut)
{
*(u32*)&Tile->x0=XYPos;
/**/ AddPrim(OtPtr,Tile);
}
Table=Table->Right;
XYPos+=XInc;
}
@ -123,5 +263,35 @@ const u32 YInc=16<<16;
}
}
/*****************************************************************************/
void CLayerTile::renderSolid()
{
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag];
sTileMap2dElem *Table=ThisTable.List;
u32 XYPos;
// Setup shift bits of pos
XYPos=ThisTable.ShiftXY;
// Calc (wrapped) Start pos
Table+=CalcTableOfs(ThisTable.MapX,ThisTable.MapY);
// Render it!!
for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++)
{
sTileMap2dElem *TableDown=Table->Down;
u32 XYPosDown=XYPos+YInc;
for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++)
{
TSPRT_16 *Tile=&Table->Tile;
*(u32*)&Tile->x0=XYPos;
/**/ AddPrim(OtPtr,Tile);
Table=Table->Right;
XYPos+=XInc;
}
Table=TableDown;
XYPos=XYPosDown;
}
}
/*****************************************************************************/

29
source/level/layertile.h
View file

@ -16,7 +16,8 @@ struct sTileMap2dElem
struct sTileMap2d
{
int X,Y;
int MapX,MapY;
u32 ShiftXY;
sTileMap2dElem *List;
};
@ -43,22 +44,27 @@ public:
};
CLayerTile(sLayerHdr *Hdr,sTile *_TileList,sTri *_TriList,sQuad *_QuadList,sVtx *_VtxList);
CLayerTile(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList);
virtual ~CLayerTile();
virtual void init()=0;
virtual void shutdown()=0;
virtual void render()=0;
virtual void think(int _frames)=0;
virtual void init(VECTOR &MapPos,int Shift,int Width=SCREEN_TILE_WIDTH,int Height=SCREEN_TILE_HEIGHT);
virtual void shutdown();
virtual void think(VECTOR &MapPos);
virtual void render();
void InitTileMap2d(int X,int Y,int Width=SCREEN_TILE_WIDTH,int Height=SCREEN_TILE_HEIGHT);
int GetWidth() {return(LayerHdr->Width);}
int GetHeight() {return(LayerHdr->Height);}
void SetMapShift(int Shift) {MapShift=Shift;}
int GetWidth() {return(LayerHdr->Width);}
int GetHeight() {return(LayerHdr->Height);}
protected:
void RenderTileMap2d(int X,int Y);
sTileMap2d &GetTileMap();
int CalcTableOfs(int X,int Y);
int CalcMapOfs(int X,int Y);
void UpdateRow(int MapX,int MapY,sTileMap2d &ThisMap);
void UpdateColumn(int MapX,int MapY,sTileMap2d &ThisMap);
void renderSolid();
sLayerHdr *LayerHdr;
sTile *TileList;
@ -67,6 +73,7 @@ protected:
sVtx *VtxList;
sTileMapElem *Map;
int MapShift;
int TileMapWidth,TileMapHeight;
sTileMap2d TileMap2d[2]; // Double Buffered
};

35
source/level/level.cpp
View file

@ -24,7 +24,8 @@ CLevel::CLevel()
}
DAVE_DBGMSG("sizeof(POLY_FT4)=%i",sizeof(POLY_FT4));
DAVE_DBGMSG("sizeof(TSPRT)=%i",sizeof(TSPRT));
MapPos.vx=0;
MapPos.vy=0;
}
/*****************************************************************************/
@ -39,10 +40,8 @@ CLevel::~CLevel()
/*****************************************************************************/
void CLevel::init()
{
// LevelHdr=(sLvlHdr *)CFileIO::loadFile(CHAPTER01_LEVEL01_LVL,"Level Data");
// TPLoadTex(CHAPTER01_LEVEL01_TEX);
LevelHdr=(sLvlHdr *)CFileIO::loadFile(LEVEL01_LEVEL01_LVL,"Level Data");
TPLoadTex(LEVEL01_LEVEL01_TEX);
LevelHdr=(sLvlHdr *)CFileIO::loadFile(LEVEL04_LEVEL04_LVL,"Level Data");
TPLoadTex(LEVEL04_LEVEL04_TEX);
initLayers();
}
@ -59,25 +58,27 @@ sTile *TileList=(sTile*)MakePtr(LevelHdr,LevelHdr->TileList);
if (LevelHdr->BackLayer)
{
sLayerHdr *Layer=(sLayerHdr*)MakePtr(LevelHdr,LevelHdr->BackLayer);
CLayerTile *NewLayer=new ("Back Layer") CLayerBack(Layer, TileList);
NewLayer->init();
CLayerTile *NewLayer=new ("Back Layer") CLayerBack(Layer, TileList, TriList, QuadList, VtxList);
NewLayer->init(MapPos,3);
TileLayers[CLayerTile::LAYER_TILE_TYPE_BACK]=NewLayer;
}
/*
// Mid
if (LevelHdr->MidLayer)
{
sLayerHdr *Layer=(sLayerHdr*)MakePtr(LevelHdr,LevelHdr->MidLayer);
CLayerTile *NewLayer=new ("Mid Layer") CLayerTile(Layer, TileList, TriList, QuadList, VtxList);
NewLayer->init();
NewLayer->init(MapPos,2);
TileLayers[CLayerTile::LAYER_TILE_TYPE_MID]=NewLayer;
}
/*
// Action
if (LevelHdr->ActionLayer)
{
sLayerHdr *Layer=(sLayerHdr*)MakePtr(LevelHdr,LevelHdr->ActionLayer);
CLayerTile *NewLayer=new ("Action Layer") CLayerTile(Layer, TileList, TriList, QuadList, VtxList);
NewLayer->init();
NewLayer->SetMapShift(0);
TileLayers[CLayerTile::LAYER_TILE_TYPE_ACTION]=NewLayer;
}
// Fore
@ -111,24 +112,22 @@ void CLevel::render()
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
extern int MapX;
extern int MapY;
int MapSpd=8;
void CLevel::think(int _frames)
{
int padh = PadGetHeld( 0 );
if (padh & PAD_LEFT) MapX-=MapSpd;
if (padh & PAD_RIGHT) MapX+=MapSpd;
if (padh & PAD_UP) MapY-=MapSpd;
if (padh & PAD_DOWN) MapY+=MapSpd;
if (padh & PAD_LEFT) MapPos.vx-=MapSpd;
if (padh & PAD_RIGHT) MapPos.vx+=MapSpd;
if (padh & PAD_UP) MapPos.vy-=MapSpd;
if (padh & PAD_DOWN) MapPos.vy+=MapSpd;
if (MapX<0) MapX=0;
if (MapY<0) MapY=0;
if (MapPos.vx<0) MapPos.vx=0;
if (MapPos.vy<0) MapPos.vy=0;
for (int i=0; i<CLayerTile::LAYER_TILE_TYPE_MAX; i++)
{
if (TileLayers[i]) TileLayers[i]->think(_frames);
if (TileLayers[i]) TileLayers[i]->think(MapPos);
}
}

2
source/level/level.h
View file

@ -25,6 +25,8 @@ private:
void initLayers();
sLvlHdr *LevelHdr;
VECTOR MapPos;
// Tile Layers
CLayerTile *TileLayers[CLayerTile::LAYER_TILE_TYPE_MAX];