Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity
9a4a7aecb4
SBSPSS/source/level/layertile3d.cpp
Daveo 368dd5c5a4
2001-07-26 15:02:16 +00:00

569 lines
14 KiB
C++
Raw Blame History

/***************************/
/*** 3d Tile Layer Class ***/
/***************************/
#include "system\global.h"
#include "system\vid.h"
#include <DStructs.h>
#include "utils\utils.h"
#include "gfx\prim.h"
#include "game\game.h"
#include "LayerTile.h"
#include "LayerTile3d.h"
#if defined(__USER_sbart__) || defined(__USER_daveo__)
#define _SHOW_POLYZ_ 1
#include "gfx\font.h"
static FontBank *Font;
int ShowPolyz=0;
#endif
static const int BLOCK_SIZE =16;
static const int SCREEN_TILE_ADJ_U =2;
static const int SCREEN_TILE_ADJ_D =1;
static const int SCREEN_TILE_ADJ_L =3;
static const int SCREEN_TILE_ADJ_R =3;
static const int SCREEN_TILE3D_WIDTH =(INGAME_SCREENW/BLOCK_SIZE)+SCREEN_TILE_ADJ_L+SCREEN_TILE_ADJ_R;
static const int SCREEN_TILE3D_HEIGHT =(INGAME_SCREENH/BLOCK_SIZE)+SCREEN_TILE_ADJ_U+SCREEN_TILE_ADJ_D;
static const int RENDER_X_OFS =INGAME_SCREENOFS_X-(SCREEN_TILE_ADJ_L*BLOCK_SIZE)+INGAME_RENDER_OFS_X;
static const int RENDER_Y_OFS =INGAME_SCREENOFS_Y-(SCREEN_TILE_ADJ_U*BLOCK_SIZE)+INGAME_RENDER_OFS_Y;
static const int DeltaTableSizeX=SCREEN_TILE3D_WIDTH+1;
static const int DeltaTableSizeY=SCREEN_TILE3D_HEIGHT+1;
/*****************************************************************************/
// 0 LUF
// 1 RUF
// 2 LDF
// 3 RDF
// 4 LUB
// 5 RUB
// 6 LDB
// 7 RDB
sFlipTable FlipTable[4]=
{
/*00 <0*/ {{+4096,0,+4096,0}, { ((DVECTOR*)SCRATCH_RAM)+0,
((DVECTOR*)SCRATCH_RAM)+1,
((DVECTOR*)SCRATCH_RAM)+2,
((DVECTOR*)SCRATCH_RAM)+3,
((DVECTOR*)SCRATCH_RAM)+4,
((DVECTOR*)SCRATCH_RAM)+5,
((DVECTOR*)SCRATCH_RAM)+6,
((DVECTOR*)SCRATCH_RAM)+7,
}, 0<<31},
/*01 >0*/ {{-4096,0,+4096,0}, { ((DVECTOR*)SCRATCH_RAM)+1,
((DVECTOR*)SCRATCH_RAM)+0,
((DVECTOR*)SCRATCH_RAM)+3,
((DVECTOR*)SCRATCH_RAM)+2,
((DVECTOR*)SCRATCH_RAM)+5,
((DVECTOR*)SCRATCH_RAM)+4,
((DVECTOR*)SCRATCH_RAM)+7,
((DVECTOR*)SCRATCH_RAM)+6,
},1<<31},
/*10 >0*/ {{+4096,0,-4096,0}, { ((DVECTOR*)SCRATCH_RAM)+2,
((DVECTOR*)SCRATCH_RAM)+3,
((DVECTOR*)SCRATCH_RAM)+0,
((DVECTOR*)SCRATCH_RAM)+1,
((DVECTOR*)SCRATCH_RAM)+6,
((DVECTOR*)SCRATCH_RAM)+7,
((DVECTOR*)SCRATCH_RAM)+4,
((DVECTOR*)SCRATCH_RAM)+5,
},1<<31},
/*11 <0*/ {{-4096,0,-4096,0}, { ((DVECTOR*)SCRATCH_RAM)+3,
((DVECTOR*)SCRATCH_RAM)+2,
((DVECTOR*)SCRATCH_RAM)+1,
((DVECTOR*)SCRATCH_RAM)+0,
((DVECTOR*)SCRATCH_RAM)+7,
((DVECTOR*)SCRATCH_RAM)+6,
((DVECTOR*)SCRATCH_RAM)+5,
((DVECTOR*)SCRATCH_RAM)+4,
},0<<31}
};
u8 RGBTable[16*4];
int RS=128;
int Ri=-6;
int GS=128;
int Gi=-6;
int BS=128;
int Bi=-6;
int AS=128;
int Ai=-6;
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
CLayerTile3d::CLayerTile3d(sLevelHdr *LevelHdr,sLayerHdr *Hdr) : CLayerTile(LevelHdr,Hdr)
{
ElemBank3d=LevelHdr->ElemBank3d;
TriList=LevelHdr->TriList;
QuadList=LevelHdr->QuadList;
VtxList=LevelHdr->VtxList;
VtxIdxList=LevelHdr->VtxIdxList;
#if defined(_SHOW_POLYZ_)
Font=new ("PrimFont") FontBank;
Font->initialise( &standardFont );
Font->setOt( 0 );
Font->setTrans(1);
#endif
for (int i=0; i<16; i++)
{
int R,G,B;
R=RS-(i*Ri);
G=GS-(i*Gi);
B=BS-(i*Bi);
if (R<0) R=0; else if (R>255) R=255;
if (G<0) G=0; else if (G>255) G=255;
if (B<0) B=0; else if (B>255) B=255;
RGBTable[(i*4)+0]=R;
RGBTable[(i*4)+1]=G;
RGBTable[(i*4)+2]=B;
RGBTable[(i*4)+3]=0;
}
}
/*****************************************************************************/
CLayerTile3d::~CLayerTile3d()
{
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CLayerTile3d::init(DVECTOR &MapPos,int Shift)
{
CLayerTile::init(MapPos,Shift);
CalcDelta();
}
/*****************************************************************************/
void CLayerTile3d::shutdown()
{
#if defined(_SHOW_POLYZ_)
Font->dump();
delete Font;
#endif
for (int i=0; i<16; i++)
{
MemFree(FTableX[i]);
MemFree(FTableY[i]);
MemFree(BTableX[i]);
MemFree(BTableY[i]);
}
}
/*****************************************************************************/
void CLayerTile3d::CalcDelta()
{
VECTOR BlkPos;
SVECTOR Pnt={-BLOCK_SIZE/2,-BLOCK_SIZE/2,-BLOCK_SIZE*4};
s16 *FTab,*BTab;
CGameScene::setCameraMtx();
for (int i=0; i<16; i++)
{
FTab=(s16*)MemAlloc(DeltaTableSizeX*sizeof(s16),"FTableXTable");
BTab=(s16*)MemAlloc(DeltaTableSizeX*sizeof(s16),"BTableXTable");
FTableX[i]=FTab;
BTableX[i]=BTab;
ASSERT(FTab);
ASSERT(BTab);
BlkPos.vx=RENDER_X_OFS-i;
BlkPos.vy=RENDER_Y_OFS;
for (int x=0; x<DeltaTableSizeX; x++)
{
s32 Tmp;
DVECTOR O;
CMX_SetTransMtxXY(&BlkPos);
Pnt.vz=-BLOCK_SIZE*4;
RotTransPers(&Pnt,(s32*)&O,&Tmp,&Tmp);
FTab[x]=O.vx;
Pnt.vz=+BLOCK_SIZE*4;
RotTransPers(&Pnt,(s32*)&O,&Tmp,&Tmp);
BTab[x]=O.vx;
BlkPos.vx+=BLOCK_SIZE;
}
FTab=(s16*)MemAlloc(DeltaTableSizeY*sizeof(s16),"FTableYTable");
BTab=(s16*)MemAlloc(DeltaTableSizeY*sizeof(s16),"BTableYTable");
FTableY[i]=FTab;
BTableY[i]=BTab;
ASSERT(FTab);
ASSERT(BTab);
BlkPos.vx=RENDER_X_OFS;
BlkPos.vy=RENDER_Y_OFS-i;
for (int y=0; y<DeltaTableSizeY; y++)
{
s32 Tmp;
DVECTOR O;
CMX_SetTransMtxXY(&BlkPos);
Pnt.vz=-BLOCK_SIZE*4;
RotTransPers(&Pnt,(s32*)&O,&Tmp,&Tmp);
FTab[y]=O.vy;
Pnt.vz=+BLOCK_SIZE*4;
RotTransPers(&Pnt,(s32*)&O,&Tmp,&Tmp);
BTab[y]=O.vy;
BlkPos.vy+=BLOCK_SIZE;
}
}
DeltaF=FTableX[0][1]-FTableX[0][0];
DeltaB=BTableY[0][1]-BTableY[0][0];
}
/*****************************************************************************/
void CLayerTile3d::think(DVECTOR &MapPos)
{
MapXY.vx=MapPos.vx>>4;
MapXY.vy=MapPos.vy>>4;
MapXY.vx-=SCREEN_TILE_ADJ_L;
MapXY.vy-=SCREEN_TILE_ADJ_U;
ShiftX=(MapPos.vx & 15);
ShiftY=(MapPos.vy & 15);
RenderOfs.vx=RenderOfs.vy=0;
DeltaFOfs.vx=DeltaFOfs.vy=0;
DeltaBOfs.vx=DeltaBOfs.vy=0;
if (MapXY.vx<0)
{
RenderOfs.vx=-MapXY.vx*BLOCK_SIZE;
DeltaFOfs.vx=-MapXY.vx*DeltaF;
DeltaBOfs.vx=-MapXY.vx*DeltaB;
MapXY.vx=0;
}
if (MapXY.vy<0)
{
RenderOfs.vy=-MapXY.vy*BLOCK_SIZE;
DeltaFOfs.vy=-MapXY.vy*DeltaF;
DeltaBOfs.vy=-MapXY.vy*DeltaB;
MapXY.vy=0;
}
if (MapXY.vx+SCREEN_TILE3D_WIDTH<=MapWidth)
RenderW=SCREEN_TILE3D_WIDTH;
else
RenderW=MapWidth-MapXY.vx;
if (MapXY.vy+SCREEN_TILE3D_HEIGHT<=MapHeight)
RenderH=SCREEN_TILE3D_HEIGHT;
else
RenderH=MapHeight-MapXY.vy;
#if defined(__USER_daveo__)
if (AS!=-1)
{
RS=GS=BS=AS;
}
if (Ai!=-1)
{
Ri=Gi=Bi=Ai;
}
for (int i=0; i<16; i++)
{
int R,G,B;
R=RS-(i*Ri);
G=GS-(i*Gi);
B=BS-(i*Bi);
if (R<0) R=0; else if (R>255) R=255;
if (G<0) G=0; else if (G>255) G=255;
if (B<0) B=0; else if (B>255) B=255;
RGBTable[(i*4)+0]=R;
RGBTable[(i*4)+1]=G;
RGBTable[(i*4)+2]=B;
RGBTable[(i*4)+3]=0;
}
#endif
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CLayerTile3d::CacheElemVtx(sElem3d *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
}
}
/*****************************************************************************/
void CLayerTile3d::render()
{
sTileMapElem *MapPtr=GetMapPos();
u8 *PrimPtr=GetPrimPtr();
u32 *XYList=(u32*)SCRATCH_RAM;
u32 T0,T1,T2,T3;
u32 P0,P1,P2,P3;
s32 ClipZ;
sOT *ThisOT;
VECTOR BlkPos;
DVECTOR *DP0,*DP1,*DP2,*DP3;
s16 *DeltaFY=FTableY[ShiftY];
s16 *DeltaBY=BTableY[ShiftY];
#if defined(_SHOW_POLYZ_)
s16 TCount=0,QCount=0;
#endif
// Setup Trans Matrix
BlkPos.vx=RENDER_X_OFS-(ShiftX)+RenderOfs.vx;
BlkPos.vy=RENDER_Y_OFS-(ShiftY)+RenderOfs.vy;
for (int Y=0; Y<RenderH; Y++)
{
sTileMapElem *MapRow=MapPtr;
s32 BlkXOld=BlkPos.vx;
s16 *DeltaFX=FTableX[ShiftX];
s16 *DeltaBX=BTableX[ShiftX];
for (int X=0; X<RenderW; X++)
{
u16 Tile=MapRow->Tile;
u16 TileIdx=Tile>>2;
u16 Flip=Tile&3;
sFlipTable *FTab=&FlipTable[Flip];
sElem3d *Elem=&ElemBank3d[TileIdx];
int TriCount=Elem->TriCount;
sTri *TList=&TriList[Elem->TriStart];
int QuadCount=Elem->QuadCount;
sQuad *QList=&QuadList[Elem->QuadStart];
if (TriCount || QuadCount) // Blank tiles rejected here, to prevent over processing (as no tri-count)
{
CMX_SetTransMtxXY(&BlkPos);
CMX_SetRotMatrixXY(&FTab->Mtx);
// --- 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;
s16 FU=DeltaFY[0]+DeltaFOfs.vy;
s16 FD=DeltaFY[1]+DeltaFOfs.vy;
DP0=FTab->DeltaTab[0];
DP1=FTab->DeltaTab[1];
DP2=FTab->DeltaTab[2];
DP3=FTab->DeltaTab[3];
DP0->vx=FL;
DP0->vy=FU;
DP1->vx=FR;
DP1->vy=FU;
DP2->vx=FL;
DP2->vy=FD;
DP3->vx=FR;
DP3->vy=FD;
s16 BL=DeltaBX[0]+DeltaBOfs.vx;
s16 BR=DeltaBX[1]+DeltaBOfs.vx;
s16 BU=DeltaBY[0]+DeltaBOfs.vy;
s16 BD=DeltaBY[1]+DeltaBOfs.vy;
DP0=FTab->DeltaTab[4];
DP1=FTab->DeltaTab[5];
DP2=FTab->DeltaTab[6];
DP3=FTab->DeltaTab[7];
DP0->vx=BL;
DP0->vy=BU;
DP1->vx=BR;
DP1->vy=BU;
DP2->vx=BL;
DP2->vy=BD;
DP3->vx=BR;
DP3->vy=BD;
// --- Render Tri's -------------
while (TriCount--)
{
POLY_GT3 *ThisPrim=(POLY_GT3*)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_PolyGT3Tag);
gte_nclip_b(); // 8 cycles
#if defined(_SHOW_POLYZ_)
if (ShowPolyz) {setRGB0(ThisPrim,127,0,0); setRGB1(ThisPrim,255,0,0); setRGB2(ThisPrim,255,0,0);}
#endif
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^=FTab->ClipCode;
if (ClipZ<0)
{
*(u32*)&ThisPrim->x0=P0; // Set XY0
*(u32*)&ThisPrim->x1=P1; // Set XY1
*(u32*)&ThisPrim->x2=P2; // Set XY2
addPrim(ThisOT,ThisPrim);
// lighting
T0=*(u32*)&RGBTable[TList->C0];
T1=*(u32*)&RGBTable[TList->C1];
T2=*(u32*)&RGBTable[TList->C2];
*(u32*)&ThisPrim->r0=T0;
*(u32*)&ThisPrim->r1=T1;
*(u32*)&ThisPrim->r2=T2;
ThisPrim->code=TList->PolyCode;
PrimPtr+=sizeof(POLY_GT3);
#if defined(_SHOW_POLYZ_)
TCount++;
#endif
}
TList++;
}
// --- Render Quads -----------
while (QuadCount--)
{
POLY_GT4 *ThisPrim=(POLY_GT4*)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_PolyGT4Tag);
gte_nclip_b(); // 8 cycles
#if defined(_SHOW_POLYZ_)
if (ShowPolyz) {setRGB0(ThisPrim,0,127,0);setRGB1(ThisPrim,0,255,0); setRGB2(ThisPrim,0,255,0); setRGB3(ThisPrim,0,255,0);}
#endif
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^=FTab->ClipCode;
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
// Lighting
T0=*(u32*)&RGBTable[QList->C0];
T1=*(u32*)&RGBTable[QList->C1];
T2=*(u32*)&RGBTable[QList->C2];
T3=*(u32*)&RGBTable[QList->C3];
*(u32*)&ThisPrim->r0=T0;
*(u32*)&ThisPrim->r1=T1;
*(u32*)&ThisPrim->r2=T2;
*(u32*)&ThisPrim->r3=T3;
ThisPrim->code=QList->PolyCode;
addPrim(ThisOT,ThisPrim);
PrimPtr+=sizeof(POLY_GT4);
#if defined(_SHOW_POLYZ_)
QCount++;
#endif
}
QList++;
}
}
MapRow++;
BlkPos.vx+=BLOCK_SIZE;
DeltaFX++; DeltaBX++;
}
MapPtr+=MapWidth;
BlkPos.vx=BlkXOld;
BlkPos.vy+=BLOCK_SIZE;
DeltaFY++; DeltaBY++;
}
SetPrimPtr((u8*)PrimPtr);
#if defined(_SHOW_POLYZ_)
char Txt[256];
sprintf(Txt,"TC %i\nQC %i",TCount,QCount);
Font->print( 128, 32, Txt);
#endif
}
View Git Blame Copy Permalink