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-14 16:38:34 +00:00
parent 18d0247548
commit 7f6a1a06b9
20 changed files with 283 additions and 154 deletions
Download patch file Download diff file Expand all files Collapse all files

259
source/level/layertile.cpp
View file

@ -24,79 +24,97 @@ CLayerTile::CLayerTile(sLayerHdr *Hdr,sTile *_TileList,sTri *_TriList,sQuad *_Qu
QuadList=_QuadList;
VtxList=_VtxList;
Map=(sTileMapElem*)MakePtr(Hdr,sizeof(sLayerHdr));
MapWidth=LayerHdr->Width;
MapHeight=LayerHdr->Height;
}
/*****************************************************************************/
CLayerTile::~CLayerTile()
{
if (TileMap2d[0].List) MemFree(TileMap2d[0].List);
if (TileMap2d[1].List) MemFree(TileMap2d[1].List);
if (TileTable[0].Table) MemFree(TileTable[0].Table);
if (TileTable[1].Table) MemFree(TileTable[1].Table);
}
/*****************************************************************************/
sTileMap2d &CLayerTile::GetTileMap()
sTileTable &CLayerTile::GetTileTable()
{
return(TileMap2d[FrameFlipFlag]);
return(TileTable[FrameFlipFlag]);
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
// NEED TO UPDATE FOR DIFF MAP POS's
void CLayerTile::init(VECTOR &MapPos,int Shift,int Width,int Height)
{
int Size=Width*Height;
int MapWidth=GetWidth();
int MapHeight=GetWidth();
ASSERT(Width>=SCREEN_TILE_WIDTH);
ASSERT(Height>=SCREEN_TILE_HEIGHT);
MapShift=Shift;
TileMapWidth=Width;
TileMapHeight=Height;
MapXYShift=Shift;
TileTableWidth=Width;
TileTableHeight=Height;
for (int Buffer=0; Buffer<2; Buffer++)
{
sTileMap2dElem *List=(sTileMap2dElem*) MemAlloc(Size*sizeof(sTileMap2dElem),"2d TileMap");
TileMap2d[Buffer].List=List;
TileMap2d[Buffer].MapX=0;
TileMap2d[Buffer].MapY=0;
sTileTableElem *Table=(sTileTableElem*) MemAlloc(Size*sizeof(sTileTableElem),"2d TileTable");
TileTable[Buffer].Table=Table;
TileTable[Buffer].MapX=0;
TileTable[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)];
sTileTableElem *ThisElem=&Table[X+(Y*Width)];
// Tile prim
TSPRT_16 *ThisTile=&ThisElem->Tile;
sTile *SrcTile=&TileList[MapPtr->Tile];
setTSprt16(ThisTile);
setTSprtTPage(ThisTile,SrcTile->TPage);
ThisTile->r0=128;
ThisTile->g0=128;
ThisTile->b0=128;
ThisTile->clut=SrcTile->Clut;
ThisTile->u0=SrcTile->uv0[0];
ThisTile->v0=SrcTile->uv0[1];
if (!MapPtr->Tile)
ThisTile->clut=0;
TSPRT_16 *Prim=&ThisElem->Prim;
setTSprt16(Prim);
setTSetShadeTex(Prim,1);
// Table
int TableR=(X+1) % Width;
int TableD=(Y+1) % Height;
ThisElem->Right=&List[TableR+(Y*Width)];
ThisElem->Down=&List[X+(TableD*Width)];
// MapPtr++;
ThisElem->Right=&Table[TableR+(Y*Width)];
ThisElem->Down=&Table[X+(TableD*Width)];
}
}
UpdateWholeMap(TileTable[Buffer]);
}
}
/*****************************************************************************/
void CLayerTile::UpdateWholeMap(sTileTable &ThisTable)
{
sTileTableElem *Table=ThisTable.Table;
sTileMapElem *MapPtr=Map;
// Calc (wrapped) Map/Table pos
Table+=CalcTableOfs(ThisTable.MapX,ThisTable.MapY);
MapPtr+=CalcMapOfs(ThisTable.MapX,ThisTable.MapY);
for (int Y=0; Y<TileTableHeight; Y++)
{
sTileTableElem *TableDown=Table->Down;
sTileMapElem *MapDown=MapPtr+MapWidth;
for (int X=0; X<TileTableWidth; X++)
{
TSPRT_16 *Prim=&Table->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
Table->Tile=Tile;
Table->TileFlags=Tile->TriCount;
Table++;
MapPtr++;
}
Table=TableDown;
MapPtr=MapDown;
}
}
/*****************************************************************************/
@ -108,18 +126,16 @@ void CLayerTile::shutdown()
/*****************************************************************************/
int CLayerTile::CalcTableOfs(int X,int Y)
{
/**/ X%=TileMapWidth;
/**/ Y%=TileMapHeight;
/**/ X%=TileTableWidth;
/**/ Y%=TileTableHeight;
/**/ return(X+(Y*TileMapWidth));
/**/ return(X+(Y*TileTableWidth));
}
/*****************************************************************************/
int CLayerTile::CalcMapOfs(int X,int Y)
{
int MapWidth=GetWidth();
int MapHeight=GetHeight();
/**/ X%=MapWidth;
/**/ Y%=MapHeight;
@ -133,9 +149,9 @@ int MapHeight=GetHeight();
void CLayerTile::think(VECTOR &MapPos)
{
// Update rows and Columns :o)
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag];
int XPos=MapPos.vx>>MapShift;
int YPos=MapPos.vy>>MapShift;
sTileTable &ThisTable=TileTable[FrameFlipFlag];
int XPos=MapPos.vx>>MapXYShift;
int YPos=MapPos.vy>>MapXYShift;
int ShiftX=15-(XPos&15);
int ShiftY=15-(YPos&15);
@ -158,7 +174,7 @@ int OldY=ThisTable.MapY;
if (NewY>OldY)
{ // update bottom row
UpdateRow(NewX,NewY+SCREEN_TILE_HEIGHT-1,ThisTable);
UpdateRow(NewX,NewY+SCREEN_TILE_HEIGHT-2,ThisTable);
}
else
if (NewY<OldY)
@ -169,30 +185,30 @@ int OldY=ThisTable.MapY;
ThisTable.MapX=NewX;
ThisTable.MapY=NewY;
ThisTable.MapX=NewX;
ThisTable.MapY=NewY;
}
/*****************************************************************************/
void CLayerTile::UpdateRow(int MapX,int MapY,sTileMap2d &ThisTable)
void CLayerTile::UpdateRow(int MapX,int MapY,sTileTable &ThisTable)
{
sTileMap2dElem *Table=ThisTable.List;
sTileTableElem *Table=ThisTable.Table;
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++)
for (int i=0; i<SCREEN_TILE_WIDTH; 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];
TSPRT_16 *Prim=&Table->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
Table->Tile=Tile;
Table->TileFlags=Tile->TriCount;
MapPtr+=1;
Table=Table->Right;
}
@ -200,12 +216,10 @@ sTileMapElem *MapPtr=Map;
}
/*****************************************************************************/
// 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)
void CLayerTile::UpdateColumn(int MapX,int MapY,sTileTable &ThisTable)
{
sTileMap2dElem *Table=ThisTable.List;
sTileTableElem *Table=ThisTable.Table;
sTileMapElem *MapPtr=Map;
int MapWidth=GetWidth();
// Calc (wrapped) Map/Table pos
Table+=CalcTableOfs(MapX,MapY);
@ -214,13 +228,13 @@ int MapWidth=GetWidth();
for (int i=0; i<SCREEN_TILE_HEIGHT; i++)
{
// Tile prim
TSPRT_16 *ThisTile=&Table->Tile;
sTile *SrcTile=&TileList[MapPtr->Tile];
TSPRT_16 *Prim=&Table->Prim;
/**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
*(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
Table->Tile=Tile;
Table->TileFlags=Tile->TriCount;
setTSprtTPage(ThisTile,SrcTile->TPage);
ThisTile->clut=SrcTile->Clut;
ThisTile->u0=SrcTile->uv0[0];
ThisTile->v0=SrcTile->uv0[1];
MapPtr+=MapWidth;
Table=Table->Down;
@ -232,8 +246,8 @@ int MapWidth=GetWidth();
/*****************************************************************************/
void CLayerTile::render()
{
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag];
sTileMap2dElem *Table=ThisTable.List;
sTileTable &ThisTable=TileTable[FrameFlipFlag];
sTileTableElem *Table=ThisTable.Table;
u32 XYPos;
// Setup shift bits of pos
@ -245,15 +259,15 @@ u32 XYPos;
// Render it!!
for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++)
{
sTileMap2dElem *TableDown=Table->Down;
sTileTableElem *TableDown=Table->Down;
u32 XYPosDown=XYPos+YInc;
for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++)
{
TSPRT_16 *Tile=&Table->Tile;
if (Tile->clut)
TSPRT_16 *Prim=&Table->Prim;
if (Prim->clut)
{
*(u32*)&Tile->x0=XYPos;
/**/ AddPrim(OtPtr,Tile);
*(u32*)&Prim->x0=XYPos;
/**/ AddPrim(OtPtr,Prim);
}
Table=Table->Right;
XYPos+=XInc;
@ -266,8 +280,8 @@ u32 XYPos;
/*****************************************************************************/
void CLayerTile::renderSolid()
{
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag];
sTileMap2dElem *Table=ThisTable.List;
sTileTable &ThisTable=TileTable[FrameFlipFlag];
sTileTableElem *Table=ThisTable.Table;
u32 XYPos;
// Setup shift bits of pos
@ -279,13 +293,64 @@ u32 XYPos;
// Render it!!
for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++)
{
sTileMap2dElem *TableDown=Table->Down;
sTileTableElem *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);
TSPRT_16 *Prim=&Table->Prim;
*(u32*)&Prim->x0=XYPos;
/**/ AddPrim(OtPtr,Prim);
Table=Table->Right;
XYPos+=XInc;
}
Table=TableDown;
XYPos=XYPosDown;
}
}
/*****************************************************************************/
VECTOR asd={0,0,512};
void CLayerTile::render3d()
{
sTileTable &ThisTable=TileTable[FrameFlipFlag];
sTileTableElem *Table=ThisTable.Table;
u32 XYPos,XYPos3d;
MATRIX _Mtx,*Mtx=&_Mtx;
SetIdent(Mtx);
Mtx->t[2]=asd.vz;
gte_SetRotMatrix(Mtx);
// 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++)
{
sTileTableElem *TableDown=Table->Down;
u32 XYPosDown=XYPos+YInc;
for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++)
{
TSPRT_16 *Prim=&Table->Prim;
if (Prim->clut)
{ // 2d tile
*(u32*)&Prim->x0=XYPos;
/**/ AddPrim(OtPtr,Prim);
}
if (Table->TileFlags)
{ // 3d tile
u32 SX=(ThisTable.ShiftXY &15);
u32 SY=(ThisTable.ShiftXY>>16);
Mtx->t[0]=((TileX-15)*16)+SX;
Mtx->t[1]=((TileY-10)*16)+SY;
gte_SetTransMatrix(Mtx);
RenderBlock(Table->Tile,Table->TileFlags);
}
Table=Table->Right;
XYPos+=XInc;
}
@ -295,3 +360,41 @@ u32 XYPos;
}
/*****************************************************************************/
// NOTE: Tiles will be sorted by z order (cos they 'should' be simple objects
// NOTE: Tiles will be split into facing strips, to reduce overdraw :o)
// NOTE: Matrix already setup for tile
void CLayerTile::RenderBlock(sTile *Tile,u32 Flags)
{
sVtx *P0,*P1,*P2;
s32 ClipZ=0;
POLY_FT3 *TPrimPtr=(POLY_FT3*)GetPrimPtr();
int TriCount=Tile->TriCount;
sTri *TList=TriList+Tile->TriList;
u32 T0,T1,T2;
//--- Tris ---------------------------------------------------------------------------
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++;
}
SetPrimPtr((u8*)TPrimPtr);
}

33
source/level/layertile.h
View file

@ -7,18 +7,20 @@
/*****************************************************************************/
struct sTileMap2dElem
struct sTileTableElem
{
TSPRT_16 Tile;
sTileMap2dElem *Right;
sTileMap2dElem *Down;
TSPRT_16 Prim;
sTile *Tile;
u32 TileFlags;
sTileTableElem *Right;
sTileTableElem *Down;
};
struct sTileMap2d
struct sTileTable
{
int MapX,MapY;
u32 ShiftXY;
sTileMap2dElem *List;
sTileTableElem *Table;
};
/*****************************************************************************/
@ -52,19 +54,18 @@ virtual void shutdown();
virtual void think(VECTOR &MapPos);
virtual void render();
void SetMapShift(int Shift) {MapShift=Shift;}
int GetWidth() {return(LayerHdr->Width);}
int GetHeight() {return(LayerHdr->Height);}
protected:
sTileMap2d &GetTileMap();
void UpdateWholeMap(sTileTable &ThisMap);
sTileTable &GetTileTable();
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 UpdateRow(int MapX,int MapY,sTileTable &ThisMap);
void UpdateColumn(int MapX,int MapY,sTileTable &ThisMap);
void renderSolid();
void render3d();
void RenderBlock(sTile *Tile,u32 Flags);
sLayerHdr *LayerHdr;
sTile *TileList;
@ -73,9 +74,9 @@ protected:
sVtx *VtxList;
sTileMapElem *Map;
int MapShift;
int TileMapWidth,TileMapHeight;
sTileMap2d TileMap2d[2]; // Double Buffered
int MapWidth,MapHeight,MapXYShift;
int TileTableWidth,TileTableHeight;
sTileTable TileTable[2]; // Double Buffered
};

18
source/level/layertile3d.cpp
View file

@ -1,6 +1,6 @@
/*******************************/
/*** Action Tile Layer Class ***/
/*******************************/
/***************************/
/*** 3d Tile Layer Class ***/
/***************************/
#include "system\global.h"
#include <DStructs.h>
@ -9,18 +9,18 @@
#include "LayerTile.h"
#include "LayerAction.h"
#include "LayerTile3d.h"
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
CLayerAction::CLayerAction(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList) : CLayerTile(Hdr,TileList,TriList,QuadList,VtxList)
CLayerTile3d::CLayerTile3d(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList) : CLayerTile(Hdr,TileList,TriList,QuadList,VtxList)
{
}
/*****************************************************************************/
CLayerAction::~CLayerAction()
CLayerTile3d::~CLayerTile3d()
{
}
@ -28,18 +28,18 @@ CLayerAction::~CLayerAction()
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CLayerAction::init(VECTOR &MapPos,int Shift,int Width,int Height)
void CLayerTile3d::init(VECTOR &MapPos,int Shift,int Width,int Height)
{
CLayerTile::init(MapPos,Shift);
}
/*****************************************************************************/
void CLayerAction::shutdown()
void CLayerTile3d::shutdown()
{
}
/*****************************************************************************/
void CLayerAction::render()
void CLayerTile3d::render()
{
// CLayerTile::render();
CLayerTile::render3d();

16
source/level/layertile3d.h
View file

@ -1,17 +1,17 @@
/*******************************/
/*** Action Tile Layer Class ***/
/*******************************/
/***************************/
/*** 3d Tile Layer Class ***/
/***************************/
#ifndef __LAYER_ACTION_H__
#define __LAYER_ACTION_H__
#ifndef __LAYER_TILE_3D_H__
#define __LAYER_TILE_3D_H__
/*****************************************************************************/
class CLayerAction : public CLayerTile
class CLayerTile3d : public CLayerTile
{
public:
CLayerAction(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList);
~CLayerAction();
CLayerTile3d(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList);
~CLayerTile3d();
void init(VECTOR &MapPos,int Shift,int Width,int Height);
void shutdown();

17
source/level/level.cpp
View file

@ -11,7 +11,8 @@
#include "level\level.h"
#include "level\layertile.h"
#include "level\layerback.h"
#include "level\layertilesolid.h"
#include "level\layertile3d.h"
#include "pad\pads.h"
@ -22,8 +23,7 @@ CLevel::CLevel()
{
TileLayers[i]=0;
}
DAVE_DBGMSG("sizeof(POLY_FT4)=%i",sizeof(POLY_FT4));
DAVE_DBGMSG("sizeof(TSPRT)=%i",sizeof(TSPRT));
MapPos.vx=0;
MapPos.vy=0;
}
@ -58,7 +58,7 @@ 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, TriList, QuadList, VtxList);
CLayerTile *NewLayer=new ("Back Layer") CLayerTileSolid(Layer, TileList, TriList, QuadList, VtxList);
NewLayer->init(MapPos,3);
TileLayers[CLayerTile::LAYER_TILE_TYPE_BACK]=NewLayer;
}
@ -71,16 +71,17 @@ sTile *TileList=(sTile*)MakePtr(LevelHdr,LevelHdr->TileList);
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);
CLayerTile *NewLayer=new ("Action Layer") CLayerTile3d(Layer, TileList, TriList, QuadList, VtxList);
NewLayer->init(MapPos,0);
TileLayers[CLayerTile::LAYER_TILE_TYPE_ACTION]=NewLayer;
}
/*
// Fore
if (LevelHdr->ForeLayer)
{