Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Utils/Libs/GLib/Frame.cpp
View File

@ -663,6 +663,28 @@ void Frame::MakeRGBA(u8 * Dest,bool ZeroIsTrans)
} }
} }
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void Frame::MakeRGB(u8 * Dest)
{
if (Buffa)
{
int Area;
Area=Width*Height;
for (int f=0;f<Area;f++)
{
Dest[f*3+0]=MyPal[Buffa[f]].GetR();
Dest[f*3+1]=MyPal[Buffa[f]].GetG();
Dest[f*3+2]=MyPal[Buffa[f]].GetB();
}
}
}
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
Purpose: Purpose:

1
Utils/Libs/GLib/Frame.hpp
View File

@ -93,6 +93,7 @@ public:
void Expand(int BorderWidth,bool DupeEdges); void Expand(int BorderWidth,bool DupeEdges);
void AddPixelSurround(int Col); void AddPixelSurround(int Col);
void MakeRGB(u8 * Dest);
void MakeRGBA(u8 * Dest,bool ZeroIsTrans=true); void MakeRGBA(u8 * Dest,bool ZeroIsTrans=true);
Frame(void); Frame(void);

8
Utils/Libs/TexGrab/AllFiles.cpp
View File

@ -82,7 +82,7 @@ void AllFiles::FileCallback(char const * FName,int FileNum)
for (f=0;f<NewEntrys.size();f++) for (f=0;f<NewEntrys.size();f++)
FileCallback(NewEntrys[f],0); FileCallback(NewEntrys[f],0);
cout<<"Read gin file *"<<FName<<"*"<<endl; if (DebugFlag) cout<<"Read gin file *"<<FName<<"*"<<endl;
} }
else else
{ {
@ -108,7 +108,7 @@ void AllFiles::FileCallback(char const * FName,int FileNum)
TheFile.Lower(); TheFile.Lower();
MyInfo.SetInfo(TheFile,CrossHair,ThisZeroColZero,MoveUVs,AllowRotate,ShrinkToFit,m_allocateAs16bit); MyInfo.SetInfo(TheFile,CrossHair,ThisZeroColZero,MoveUVs,AllowRotate,ShrinkToFit,m_allocateAs16bit);
cout<<"Add image file "<<TheFile<<endl; if (DebugFlag) cout<<"Add image file "<<TheFile<<endl;
if (ForceOffsets) if (ForceOffsets)
MyInfo.SetForceOffsets(XOff,YOff); MyInfo.SetForceOffsets(XOff,YOff);
@ -144,7 +144,7 @@ void AllFiles::AddMemFrame(char const * FName,Frame &Frame)
TheFile.Lower(); TheFile.Lower();
MyInfo.SetInfo(TheFile,CrossHair,ThisZeroColZero,MoveUVs,AllowRotate,ShrinkToFit,m_allocateAs16bit,&Frame); MyInfo.SetInfo(TheFile,CrossHair,ThisZeroColZero,MoveUVs,AllowRotate,ShrinkToFit,m_allocateAs16bit,&Frame);
cout<<"Add MemFrame "<<TheFile<<endl; if (DebugFlag) cout<<"Add MemFrame "<<TheFile<<endl;
if (ForceOffsets) if (ForceOffsets)
MyInfo.SetForceOffsets(XOff,YOff); MyInfo.SetForceOffsets(XOff,YOff);
@ -194,7 +194,7 @@ void AllFiles::ReadRepFile(char const * Name)
for (int f=0;f<MyItems.size();f++) for (int f=0;f<MyItems.size();f++)
AllExternalSharedTextures.push_back(MyItems[f].m_texName); AllExternalSharedTextures.push_back(MyItems[f].m_texName);
cout<<"Read report file "<<Name<<endl; if (DebugFlag) cout<<"Read report file "<<Name<<endl;
} }
/*=========================================================================== /*===========================================================================

3
Utils/Libs/TexGrab/AllFiles.h
View File

@ -53,6 +53,7 @@ public:
m_allocateAs16bit=false; m_allocateAs16bit=false;
MaxSize=0; MaxSize=0;
m_noSort=false; m_noSort=false;
DebugFlag=false;
} }
void SetFileRecursion(bool NewRecurseFiles) {RecurseFiles=NewRecurseFiles;} void SetFileRecursion(bool NewRecurseFiles) {RecurseFiles=NewRecurseFiles;}
@ -65,6 +66,7 @@ public:
void SetXOff(int NewXOff) {XOff=NewXOff;} void SetXOff(int NewXOff) {XOff=NewXOff;}
void SetYOff(int NewYOff) {YOff=NewYOff;} void SetYOff(int NewYOff) {YOff=NewYOff;}
void SetMaxSize(int New) {MaxSize=New;} void SetMaxSize(int New) {MaxSize=New;}
void SetDebug(bool f) {DebugFlag=f;}
int GetMaxSize(void) const {return(MaxSize);} int GetMaxSize(void) const {return(MaxSize);}
@ -100,6 +102,7 @@ protected:
FIVec AllFileInfos; FIVec AllFileInfos;
int MaxSize; int MaxSize;
bool DebugFlag;
}; };

1
Utils/Libs/TexGrab/TexGrab.cpp
View File

@ -65,6 +65,7 @@ CTexGrab::~CTexGrab()
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CTexGrab::Process() void CTexGrab::Process()
{ {
MySprSet.setDebug(DebugFlag);
MySprSet.setHalfTpage(m_useHalfTpage); MySprSet.setHalfTpage(m_useHalfTpage);
MySprSet.setAnimatedHeader(m_AnimatedHeadersOnly); MySprSet.setAnimatedHeader(m_AnimatedHeadersOnly);
MySprSet.setDontOutputBoxes(m_DontOutputBoxes); MySprSet.setDontOutputBoxes(m_DontOutputBoxes);

3
Utils/Libs/TexGrab/TexGrab.h
View File

@ -69,6 +69,7 @@ public:
void AllowRotate(bool f) {MyFiles.SetAllowRotate(f);} void AllowRotate(bool f) {MyFiles.SetAllowRotate(f);}
void FileRecursion(bool f) {MyFiles.SetFileRecursion(f);} void FileRecursion(bool f) {MyFiles.SetFileRecursion(f);}
void NoSort() {MyFiles.setNoSort();} void NoSort() {MyFiles.setNoSort();}
void SetDebug(bool f) {DebugFlag=f;}
void ReadRepFile(GString String) {MyFiles.ReadRepFile(String);} void ReadRepFile(GString String) {MyFiles.ReadRepFile(String);}
@ -114,7 +115,7 @@ protected:
bool m_AnimatedHeadersOnly; bool m_AnimatedHeadersOnly;
bool m_DontOutputBoxes; bool m_DontOutputBoxes;
bool m_AlignHeaders; bool m_AlignHeaders;
bool DebugFlag;
std::vector<sTexOutInfo> TexInfo; std::vector<sTexOutInfo> TexInfo;
}; };

8
Utils/Libs/TexGrab/sprset.cpp
View File

@ -210,7 +210,7 @@ void SprSet::AddAnm(FileInfo const & ThisInfo)
AddFrame(ThisAnim[f],TempFileInfo); AddFrame(ThisAnim[f],TempFileInfo);
} }
cout<<"Added anim file "<<ThisInfo.GetFileName()<<" ("<<ThisAnim.NumOfFrames()<<" frames)"<<endl; if (DebugFlag) cout<<"Added anim file "<<ThisInfo.GetFileName()<<" ("<<ThisAnim.NumOfFrames()<<" frames)"<<endl;
} }
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
@ -287,7 +287,7 @@ void SprSet::ProcessPals(void)
AllSprPals[PalIndex].SetPalIndex(PalIndex); AllSprPals[PalIndex].SetPalIndex(PalIndex);
} }
cout<<"Found "<<AllSprPals.size()<<" unique pal(s)"<<endl; if (DebugFlag) cout<<"Found "<<AllSprPals.size()<<" unique pal(s)"<<endl;
} }
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
@ -533,7 +533,7 @@ int FrameCount=AllSprFrames.size();
} }
size=int(Out.tellp())-thisPos; size=int(Out.tellp())-thisPos;
cout<<"size of headers == "<<size<<endl; if (DebugFlag) cout<<"size of headers == "<<size<<endl;
Out.Align(sizeof(u32)); Out.Align(sizeof(u32));
@ -944,7 +944,7 @@ void SprFrame::SetFrameAndInfo(Frame const & Fr,FileInfo const & NewMyFileInfo,i
cout<<"Reducing frame "<<GetFileInfo()->GetActualFileName()<<endl; cout<<"Reducing frame "<<GetFileInfo()->GetActualFileName()<<endl;
ResizeAndReduce(*this,GetNumOfCols(),float(NewWidth)/float(GetWidth()),float(NewHeight)/float(GetHeight()),MyFileInfo.GetZeroColZero()); ResizeAndReduce(*this,GetNumOfCols(),float(NewWidth)/float(GetWidth()),float(NewHeight)/float(GetHeight()),MyFileInfo.GetZeroColZero());
#if 1 #if 0
char Name[1024]; char Name[1024];
static int Val; static int Val;
sprintf(Name,"c:\\data\\%d.lbm",Val); sprintf(Name,"c:\\data\\%d.lbm",Val);

4
Utils/Libs/TexGrab/sprset.h
View File

@ -515,6 +515,7 @@ public:
{ {
Vi=NULL; Vi=NULL;
MaxSize=0; MaxSize=0;
DebugFlag=false;
} }
void SetMaxSize(int New) void SetMaxSize(int New)
@ -549,6 +550,8 @@ public:
void setNoWriteTpages(bool newVal) void setNoWriteTpages(bool newVal)
{m_noWriteTpages=newVal;} {m_noWriteTpages=newVal;}
void setDebug(bool f)
{DebugFlag=f;}
protected: protected:
void WriteHeaderFile(char const * HName); void WriteHeaderFile(char const * HName);
@ -578,6 +581,7 @@ protected:
bool m_halfTpage; bool m_halfTpage;
bool m_compressTpages; bool m_compressTpages;
bool m_noWriteTpages; bool m_noWriteTpages;
bool DebugFlag;
SprFrVec AllSprFrames; SprFrVec AllSprFrames;
SprPalVec AllSprPals; SprPalVec AllSprPals;

2
Utils/MapEdit/MapEdit.dsp
View File

@ -79,7 +79,7 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo # ADD BSC32 /nologo
LINK32=link.exe LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept # ADD BASE LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
# ADD LINK32 opengl32.lib glu32.lib glib.lib ginlib.lib glaux.lib maths.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept /libpath:"..\libs\ginlib\debug\\" /libpath:"..\libs\glib\debug\\" /libpath:"..\libs\maths\debug\\" # ADD LINK32 opengl32.lib glu32.lib glib.lib ginlib.lib maths.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept /libpath:"..\libs\ginlib\debug\\" /libpath:"..\libs\glib\debug\\" /libpath:"..\libs\maths\debug\\"
!ENDIF !ENDIF

2
Utils/MapEdit/TileSet.cpp
View File

@ -412,7 +412,7 @@ sTex &ThisTex=TexCache.GetTex(TexID);
int Width=ThisTex.TexWidth/16; int Width=ThisTex.TexWidth/16;
int Height=ThisTex.TexHeight/16; int Height=ThisTex.TexHeight/16;
TRACE3("Load 2d TileBank %s (%i,%i)\n",Filename.FullName(),Width,Height); // TRACE3("Load 2d TileBank %s (%i,%i)\n",Filename.FullName(),Width,Height);
Tile.push_back(CTile(0)); // Insert Blank Tile.push_back(CTile(0)); // Insert Blank

1
Utils/MapEdit/TileSet.h
View File

@ -108,6 +108,7 @@ public:
void Load2d(CCore *Core); void Load2d(CCore *Core);
void Load3d(CCore *Core); void Load3d(CCore *Core);
const char *GetDrive() {return(Filename.Drive());}
const char *GetPath() {return(Filename.Dir());} const char *GetPath() {return(Filename.Dir());}
const char *GetName() {return(Filename.File());} const char *GetName() {return(Filename.File());}
const char *GetExt() {return(Filename.Ext());} const char *GetExt() {return(Filename.Ext());}

4
makefile.gaz
View File

@ -86,8 +86,8 @@ gui_src := gbutton \
level_src := level \ level_src := level \
layertile \ layertile \
layerback \ layertilesolid \
layeraction layertile3d
locale_src := textdbase locale_src := textdbase

2
makefile.gfx
View File

@ -38,7 +38,7 @@ TEMP_FILE := $(TEMP_BUILD_DIR)/build.tmp
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
#--- Levels ----------------------------------------------------------------- #--- Levels -----------------------------------------------------------------
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
LEVELS_OPTS := -t:8,2,1 -s:256 LEVELS_OPTS := -t:8,2,1 -s:16
LEVELS_IN_DIR := $(GRAF_DIR)/levels LEVELS_IN_DIR := $(GRAF_DIR)/levels
LEVELS_OUT_DIR := $(DATA_OUT)/levels LEVELS_OUT_DIR := $(DATA_OUT)/levels

259
source/level/layertile.cpp
View File

@ -24,79 +24,97 @@ CLayerTile::CLayerTile(sLayerHdr *Hdr,sTile *_TileList,sTri *_TriList,sQuad *_Qu
QuadList=_QuadList; QuadList=_QuadList;
VtxList=_VtxList; VtxList=_VtxList;
Map=(sTileMapElem*)MakePtr(Hdr,sizeof(sLayerHdr)); Map=(sTileMapElem*)MakePtr(Hdr,sizeof(sLayerHdr));
MapWidth=LayerHdr->Width;
MapHeight=LayerHdr->Height;
} }
/*****************************************************************************/ /*****************************************************************************/
CLayerTile::~CLayerTile() CLayerTile::~CLayerTile()
{ {
if (TileMap2d[0].List) MemFree(TileMap2d[0].List); if (TileTable[0].Table) MemFree(TileTable[0].Table);
if (TileMap2d[1].List) MemFree(TileMap2d[1].List); 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) void CLayerTile::init(VECTOR &MapPos,int Shift,int Width,int Height)
{ {
int Size=Width*Height; int Size=Width*Height;
int MapWidth=GetWidth();
int MapHeight=GetWidth();
ASSERT(Width>=SCREEN_TILE_WIDTH); ASSERT(Width>=SCREEN_TILE_WIDTH);
ASSERT(Height>=SCREEN_TILE_HEIGHT); ASSERT(Height>=SCREEN_TILE_HEIGHT);
MapShift=Shift; MapXYShift=Shift;
TileMapWidth=Width; TileTableWidth=Width;
TileMapHeight=Height; TileTableHeight=Height;
for (int Buffer=0; Buffer<2; Buffer++) for (int Buffer=0; Buffer<2; Buffer++)
{ {
sTileMap2dElem *List=(sTileMap2dElem*) MemAlloc(Size*sizeof(sTileMap2dElem),"2d TileMap"); sTileTableElem *Table=(sTileTableElem*) MemAlloc(Size*sizeof(sTileTableElem),"2d TileTable");
TileMap2d[Buffer].List=List; TileTable[Buffer].Table=Table;
TileMap2d[Buffer].MapX=0; TileTable[Buffer].MapX=0;
TileMap2d[Buffer].MapY=0; TileTable[Buffer].MapY=0;
for (int Y=0; Y<Height; Y++) for (int Y=0; Y<Height; Y++)
{ {
for (int X=0; X<Width; X++) for (int X=0; X<Width; X++)
{ {
sTileMapElem *MapPtr=&Map[X+(Y*MapWidth)]; sTileTableElem *ThisElem=&Table[X+(Y*Width)];
sTileMap2dElem *ThisElem=&List[X+(Y*Width)];
// Tile prim // Tile prim
TSPRT_16 *ThisTile=&ThisElem->Tile; TSPRT_16 *Prim=&ThisElem->Prim;
sTile *SrcTile=&TileList[MapPtr->Tile]; setTSprt16(Prim);
setTSprt16(ThisTile); setTSetShadeTex(Prim,1);
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;
// Table // Table
int TableR=(X+1) % Width; int TableR=(X+1) % Width;
int TableD=(Y+1) % Height; int TableD=(Y+1) % Height;
ThisElem->Right=&List[TableR+(Y*Width)]; ThisElem->Right=&Table[TableR+(Y*Width)];
ThisElem->Down=&List[X+(TableD*Width)]; ThisElem->Down=&Table[X+(TableD*Width)];
// MapPtr++;
} }
} }
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) int CLayerTile::CalcTableOfs(int X,int Y)
{ {
/**/ X%=TileMapWidth; /**/ X%=TileTableWidth;
/**/ Y%=TileMapHeight; /**/ Y%=TileTableHeight;
/**/ return(X+(Y*TileMapWidth)); /**/ return(X+(Y*TileTableWidth));
} }
/*****************************************************************************/ /*****************************************************************************/
int CLayerTile::CalcMapOfs(int X,int Y) int CLayerTile::CalcMapOfs(int X,int Y)
{ {
int MapWidth=GetWidth();
int MapHeight=GetHeight();
/**/ X%=MapWidth; /**/ X%=MapWidth;
/**/ Y%=MapHeight; /**/ Y%=MapHeight;
@ -133,9 +149,9 @@ int MapHeight=GetHeight();
void CLayerTile::think(VECTOR &MapPos) void CLayerTile::think(VECTOR &MapPos)
{ {
// Update rows and Columns :o) // Update rows and Columns :o)
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag]; sTileTable &ThisTable=TileTable[FrameFlipFlag];
int XPos=MapPos.vx>>MapShift; int XPos=MapPos.vx>>MapXYShift;
int YPos=MapPos.vy>>MapShift; int YPos=MapPos.vy>>MapXYShift;
int ShiftX=15-(XPos&15); int ShiftX=15-(XPos&15);
int ShiftY=15-(YPos&15); int ShiftY=15-(YPos&15);
@ -158,7 +174,7 @@ int OldY=ThisTable.MapY;
if (NewY>OldY) if (NewY>OldY)
{ // update bottom row { // update bottom row
UpdateRow(NewX,NewY+SCREEN_TILE_HEIGHT-1,ThisTable); UpdateRow(NewX,NewY+SCREEN_TILE_HEIGHT-2,ThisTable);
} }
else else
if (NewY<OldY) if (NewY<OldY)
@ -169,30 +185,30 @@ int OldY=ThisTable.MapY;
ThisTable.MapX=NewX; ThisTable.MapX=NewX;
ThisTable.MapY=NewY; 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; sTileMapElem *MapPtr=Map;
//int MapWidth=GetWidth();
// Calc (wrapped) Map/Table pos // Calc (wrapped) Map/Table pos
Table+=CalcTableOfs(MapX,MapY); Table+=CalcTableOfs(MapX,MapY);
MapPtr+=CalcMapOfs(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 // Tile prim
TSPRT_16 *ThisTile=&Table->Tile; TSPRT_16 *Prim=&Table->Prim;
sTile *SrcTile=&TileList[MapPtr->Tile]; /**/ sTile *Tile=&TileList[MapPtr->Tile];
/**/ setTSprtTPage(Prim,Tile->TPage);
setTSprtTPage(ThisTile,SrcTile->TPage); *(u32*)&Prim->u0=*(u32*)&Tile->u0; // copy uv AND clut
ThisTile->clut=SrcTile->Clut; Table->Tile=Tile;
ThisTile->u0=SrcTile->uv0[0]; Table->TileFlags=Tile->TriCount;
ThisTile->v0=SrcTile->uv0[1];
MapPtr+=1; MapPtr+=1;
Table=Table->Right; 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,sTileTable &ThisTable)
void CLayerTile::UpdateColumn(int MapX,int MapY,sTileMap2d &ThisTable)
{ {
sTileMap2dElem *Table=ThisTable.List; sTileTableElem *Table=ThisTable.Table;
sTileMapElem *MapPtr=Map; sTileMapElem *MapPtr=Map;
int MapWidth=GetWidth();
// Calc (wrapped) Map/Table pos // Calc (wrapped) Map/Table pos
Table+=CalcTableOfs(MapX,MapY); Table+=CalcTableOfs(MapX,MapY);
@ -214,13 +228,13 @@ int MapWidth=GetWidth();
for (int i=0; i<SCREEN_TILE_HEIGHT; i++) for (int i=0; i<SCREEN_TILE_HEIGHT; i++)
{ {
// Tile prim // Tile prim
TSPRT_16 *ThisTile=&Table->Tile; TSPRT_16 *Prim=&Table->Prim;
sTile *SrcTile=&TileList[MapPtr->Tile]; /**/ 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; MapPtr+=MapWidth;
Table=Table->Down; Table=Table->Down;
@ -232,8 +246,8 @@ int MapWidth=GetWidth();
/*****************************************************************************/ /*****************************************************************************/
void CLayerTile::render() void CLayerTile::render()
{ {
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag]; sTileTable &ThisTable=TileTable[FrameFlipFlag];
sTileMap2dElem *Table=ThisTable.List; sTileTableElem *Table=ThisTable.Table;
u32 XYPos; u32 XYPos;
// Setup shift bits of pos // Setup shift bits of pos
@ -245,15 +259,15 @@ u32 XYPos;
// Render it!! // Render it!!
for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++) for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++)
{ {
sTileMap2dElem *TableDown=Table->Down; sTileTableElem *TableDown=Table->Down;
u32 XYPosDown=XYPos+YInc; u32 XYPosDown=XYPos+YInc;
for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++) for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++)
{ {
TSPRT_16 *Tile=&Table->Tile; TSPRT_16 *Prim=&Table->Prim;
if (Tile->clut) if (Prim->clut)
{ {
*(u32*)&Tile->x0=XYPos; *(u32*)&Prim->x0=XYPos;
/**/ AddPrim(OtPtr,Tile); /**/ AddPrim(OtPtr,Prim);
} }
Table=Table->Right; Table=Table->Right;
XYPos+=XInc; XYPos+=XInc;
@ -266,8 +280,8 @@ u32 XYPos;
/*****************************************************************************/ /*****************************************************************************/
void CLayerTile::renderSolid() void CLayerTile::renderSolid()
{ {
sTileMap2d &ThisTable=TileMap2d[FrameFlipFlag]; sTileTable &ThisTable=TileTable[FrameFlipFlag];
sTileMap2dElem *Table=ThisTable.List; sTileTableElem *Table=ThisTable.Table;
u32 XYPos; u32 XYPos;
// Setup shift bits of pos // Setup shift bits of pos
@ -279,13 +293,64 @@ u32 XYPos;
// Render it!! // Render it!!
for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++) for (int TileY=0; TileY<SCREEN_TILE_HEIGHT; TileY++)
{ {
sTileMap2dElem *TableDown=Table->Down; sTileTableElem *TableDown=Table->Down;
u32 XYPosDown=XYPos+YInc; u32 XYPosDown=XYPos+YInc;
for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++) for (int TileX=0; TileX<SCREEN_TILE_WIDTH; TileX++)
{ {
TSPRT_16 *Tile=&Table->Tile; TSPRT_16 *Prim=&Table->Prim;
*(u32*)&Tile->x0=XYPos; *(u32*)&Prim->x0=XYPos;
/**/ AddPrim(OtPtr,Tile); /**/ 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; Table=Table->Right;
XYPos+=XInc; 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; TSPRT_16 Prim;
sTileMap2dElem *Right; sTile *Tile;
sTileMap2dElem *Down; u32 TileFlags;
sTileTableElem *Right;
sTileTableElem *Down;
}; };
struct sTileMap2d struct sTileTable
{ {
int MapX,MapY; int MapX,MapY;
u32 ShiftXY; u32 ShiftXY;
sTileMap2dElem *List; sTileTableElem *Table;
}; };
/*****************************************************************************/ /*****************************************************************************/
@ -52,19 +54,18 @@ virtual void shutdown();
virtual void think(VECTOR &MapPos); virtual void think(VECTOR &MapPos);
virtual void render(); virtual void render();
void SetMapShift(int Shift) {MapShift=Shift;}
int GetWidth() {return(LayerHdr->Width);}
int GetHeight() {return(LayerHdr->Height);}
protected: protected:
sTileMap2d &GetTileMap(); void UpdateWholeMap(sTileTable &ThisMap);
sTileTable &GetTileTable();
int CalcTableOfs(int X,int Y); int CalcTableOfs(int X,int Y);
int CalcMapOfs(int X,int Y); int CalcMapOfs(int X,int Y);
void UpdateRow(int MapX,int MapY,sTileMap2d &ThisMap); void UpdateRow(int MapX,int MapY,sTileTable &ThisMap);
void UpdateColumn(int MapX,int MapY,sTileMap2d &ThisMap); void UpdateColumn(int MapX,int MapY,sTileTable &ThisMap);
void renderSolid(); void renderSolid();
void render3d();
void RenderBlock(sTile *Tile,u32 Flags);
sLayerHdr *LayerHdr; sLayerHdr *LayerHdr;
sTile *TileList; sTile *TileList;
@ -73,9 +74,9 @@ protected:
sVtx *VtxList; sVtx *VtxList;
sTileMapElem *Map; sTileMapElem *Map;
int MapShift; int MapWidth,MapHeight,MapXYShift;
int TileMapWidth,TileMapHeight; int TileTableWidth,TileTableHeight;
sTileMap2d TileMap2d[2]; // Double Buffered 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 "system\global.h"
#include <DStructs.h> #include <DStructs.h>
@ -9,18 +9,18 @@
#include "LayerTile.h" #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); CLayerTile::init(MapPos,Shift);
} }
/*****************************************************************************/ /*****************************************************************************/
void CLayerAction::shutdown() void CLayerTile3d::shutdown()
{ {
} }
/*****************************************************************************/ /*****************************************************************************/
void CLayerAction::render() void CLayerTile3d::render()
{ {
// CLayerTile::render(); // CLayerTile::render();
CLayerTile::render3d(); 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__ #ifndef __LAYER_TILE_3D_H__
#define __LAYER_ACTION_H__ #define __LAYER_TILE_3D_H__
/*****************************************************************************/ /*****************************************************************************/
class CLayerAction : public CLayerTile class CLayerTile3d : public CLayerTile
{ {
public: public:
CLayerAction(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList); CLayerTile3d(sLayerHdr *Hdr,sTile *TileList,sTri *TriList,sQuad *QuadList,sVtx *VtxList);
~CLayerAction(); ~CLayerTile3d();
void init(VECTOR &MapPos,int Shift,int Width,int Height); void init(VECTOR &MapPos,int Shift,int Width,int Height);
void shutdown(); void shutdown();

17
source/level/level.cpp
View File

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

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

Binary file not shown.

33
tools/Data/include/dstructs.h
View File

@ -82,12 +82,14 @@ struct sMat
//*************************************************************************** //***************************************************************************
struct sTri struct sTri
{ {
u16 P0,P1,P2; // 6 u16 P0; // 2
u16 TPage; // 2 u16 P1; // 2
u8 uv0[2]; // 2 u8 uv0[2]; // 2
u8 uv1[2]; // 2
u8 uv2[2]; // 2
u16 Clut; // 2 u16 Clut; // 2
u8 uv1[2]; // 2
u16 TPage; // 2
u8 uv2[2]; // 2
u16 P2; // 2
}; // 16 }; // 16
// u8 r0, g0, b0, code; // 4 // u8 r0, g0, b0, code; // 4
@ -137,7 +139,7 @@ struct sBone
struct sTileMapElem struct sTileMapElem
{ {
u16 Tile; u16 Tile;
}; };
struct sTile struct sTile
@ -148,14 +150,10 @@ struct sTile
u16 QuadList; u16 QuadList;
u16 QuadCount; u16 QuadCount;
// 2d Tile // 2d Tile
// s16 Mat2d; u8 u0,v0;
// s8 XOfs,YOfs;
u16 TPage;
u16 Clut; u16 Clut;
u8 uv0[2]; u16 TPage;
u8 uv1[2]; u16 Pad; // :o( need this?
u8 uv2[2];
u8 uv3[2];
#ifdef WIN32 #ifdef WIN32
bool operator==(sTile const &v1) bool operator==(sTile const &v1)
@ -166,15 +164,8 @@ bool operator==(sTile const &v1)
// if (QuadList!=v1.QuadList) return(false); // if (QuadList!=v1.QuadList) return(false);
if (TPage!=v1.TPage) return(false); if (TPage!=v1.TPage) return(false);
// if (Mat!=v1.Mat) return(false); if (u0!=v1.u0) return(false);
if (uv0[0]!=v1.uv0[0]) return(false); if (v0!=v1.v0) return(false);
if (uv0[1]!=v1.uv0[1]) return(false);
if (uv1[0]!=v1.uv1[0]) return(false);
if (uv1[1]!=v1.uv1[1]) return(false);
if (uv2[0]!=v1.uv2[0]) return(false);
if (uv2[1]!=v1.uv2[1]) return(false);
if (uv3[0]!=v1.uv3[0]) return(false);
if (uv3[1]!=v1.uv3[1]) return(false);
return(TRUE); return(TRUE);
} }
#endif #endif