Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity

Browse Source
This commit is contained in:
Daveo 2001-04-09 21:27:21 +00:00
parent 3dfa898b73
commit 944a38a726
6 changed files with 331 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/enemy/npc.cpp
View File

@ -221,7 +221,7 @@ void CNpcEnemy::CacheActor(int Type)
{
int m_type = mapEditConvertTable[Type - NPC_ENEMY_MAPEDIT_OFFSET];
CActorPool::GetActor(m_data[m_type].skelType);
CActorPool::AddActor(m_data[m_type].skelType);
}

363
source/gfx/actor.cpp
View File

@ -12,6 +12,10 @@
#include <dstructs.h>
/*****************************************************************************/
int ShadowXOfs=32;
int ShadowYOfs=32;
/*****************************************************************************/
CActorPool::ACTOR_TYPE CActorPool::actorType[38] =
@ -57,69 +61,261 @@ CActorPool::ACTOR_TYPE CActorPool::actorType[38] =
};
/*****************************************************************************/
CActorGfx *CActorPool::ActorList[CActorPool::MAX_ACTORS];
u8 CActorPool::UnpackBuffer[CActorPool::MAX_ACTOR_SIZE];
sActorPool CActorPool::ActorPool[MAX_ACTORS];
CSlotCache CActorGfx::SlotCache;
u8 CActorGfx::UnpackBuffer[CActorPool::MAX_ACTOR_SIZE];
/*****************************************************************************/
/*** Slot Cache **************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CActorGfx::Init(FileEquate _Filename)
void CSlotCache::Init()
{
CActorPool::GetActor(Filename);
for (int Y=0; Y<DYN_SLOTH; Y++)
{
for (int X=0; X<DYN_SLOTW; X++)
{
Cache[X][Y].W=0;
}
}
}
int DefTPX=512;
int DefTPY=256;
int ShadowXOfs=32;
int ShadowYOfs=32;
int TPInc=64;
/*****************************************************************************/
bool CSlotCache::FindSlot(int SprW,int SprH,u16 &TexX,u16 &TexY,u8 &u,u8 &v)
{
int W=(SprW+(DYN_W-1))/DYN_W;
int H=(SprH+(DYN_H-1))/DYN_H;
for (int Y=0; Y<DYN_SLOTH; Y++)
{
for (int X=0; X<DYN_SLOTW; X++)
{
if (TakeSlot(X,Y,W,H))
{
printf("TakeSlot %i %i\n",X,Y);
TexX=DYN_SLOTX+(X*DYN_W/4);
TexY=DYN_SLOTY+(Y*DYN_H);
u=(X&3)*64;
v=(Y&3)*64;
return(true);
}
}
}
return(false);
}
/*****************************************************************************/
CActorGfx::CActorGfx(FileEquate _Filename,int Idx)
bool CSlotCache::TakeSlot(int SX,int SY,int SW,int SH)
{
int W,H;
if (SX+SW>DYN_SLOTW) return(false);
if (SY+SH>DYN_SLOTH) return(false);
if ((SX&3)==3 && SW>1) return(false);
for (H=0; H<SH; H++)
{
for (W=0; W<SW; W++)
{
if (Cache[SX+W][SY+H].W) return(false);
}
}
// Slot good
for (H=0; H<SH; H++)
{
for (W=0; W<SW; W++)
{
Cache[SX+W][SY+H].W=SW;
Cache[SX+W][SY+H].H=SH;
}
}
return(true);
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CActorPool::Init()
{
int i;
for (i=0; i<MAX_ACTORS; i++)
{
ActorPool[i].SpriteBank=0;
}
CActorGfx::ResetCache();
}
/*****************************************************************************/
int CActorPool::FindActorInPool(FileEquate Filename)
{
for (int i=0; i<MAX_ACTORS; i++)
{
if (ActorPool[i].SpriteBank && ActorPool[i].Filename==Filename) return(i);
}
return(-1);
}
/*****************************************************************************/
int CActorPool::FindFreeActor()
{
for (int i=0; i<MAX_ACTORS; i++)
{
if (ActorPool[i].SpriteBank==0) return(i);
}
return(-1);
}
/*****************************************************************************/
int CActorPool::LoadActor(FileEquate Filename)
{
int i;
Filename=_Filename;
ActorNo=Idx;
SpriteBank=(sSpriteAnimBank*)CFileIO::loadFile(Filename);
sSpriteAnimBank *Spr=(sSpriteAnimBank*)CFileIO::loadFile(Filename);
SpriteBank->AnimList=(sSpriteAnim*) MakePtr(SpriteBank,(int)SpriteBank->AnimList);
SpriteBank->FrameList=(sSpriteFrame*) MakePtr(SpriteBank,(int)SpriteBank->FrameList);
SpriteBank->Palette=(u8*) MakePtr(SpriteBank,(int)SpriteBank->Palette);
Spr->AnimList=(sSpriteAnim*) MakePtr(Spr,(int)Spr->AnimList);
Spr->FrameList=(sSpriteFrame*) MakePtr(Spr,(int)Spr->FrameList);
Spr->Palette=(u8*) MakePtr(Spr,(int)Spr->Palette);
// FixUp AnimList
DAVE_DBGMSG("Anims %i\n",SpriteBank->AnimCount);
for (i=0; i<SpriteBank->AnimCount; i++)
DAVE_DBGMSG("Anims %i\n",Spr->AnimCount);
for (i=0; i<Spr->AnimCount; i++)
{
sSpriteAnim *ThisAnim=&SpriteBank->AnimList[i];
ThisAnim->Anim=(u16*) MakePtr(SpriteBank,(int)ThisAnim->Anim);
sSpriteAnim *ThisAnim=&Spr->AnimList[i];
ThisAnim->Anim=(u16*) MakePtr(Spr,(int)ThisAnim->Anim);
}
// FixUp FrameList
DAVE_DBGMSG("Anims %i\n",SpriteBank->FrameCount);
for (i=0; i<SpriteBank->FrameCount; i++)
DAVE_DBGMSG("Anims %i\n",Spr->FrameCount);
for (i=0; i<Spr->FrameCount; i++)
{
sSpriteFrame *ThisFrame=&SpriteBank->FrameList[i];
ThisFrame->PAKSpr=(u8*) MakePtr(SpriteBank,(int)ThisFrame->PAKSpr);
sSpriteFrame *ThisFrame=&Spr->FrameList[i];
ThisFrame->PAKSpr=(u8*) MakePtr(Spr,(int)ThisFrame->PAKSpr);
}
TexX=DefTPX+(TPInc*ActorNo);
TexY=DefTPY+4;
ClutX=TexX;
ClutY=DefTPY;
// Store it
int Idx=FindFreeActor();
ASSERT(Idx!=-1);
// upload clut
RECT Rect;
Rect.x=ClutX;
Rect.y=ClutY;
Rect.w=SpriteBank->ColorCount;
Rect.h=1;
LoadImage( &Rect, (u32*)SpriteBank->Palette);
sActorPool &ThisActor=ActorPool[Idx];
ThisActor.Filename=Filename;
ThisActor.SpriteBank=Spr;
ThisActor.RefCount=1;
ThisActor.Clut=LoadPalette(ThisActor,Idx);
return(Idx);
}
/*****************************************************************************/
#define DYN_PALW 64
#define DYN_PALH 1
#define DYN_PALX DYN_PALW*(8+4)
#define DYN_PALY 511
u16 CActorPool::LoadPalette(sActorPool &ThisActor,int Idx)
{
RECT R;
R.x=DYN_PALX+(Idx*DYN_PALW);
R.y=DYN_PALY;
R.w=DYN_PALW;
R.h=DYN_PALH;
LoadImage( &R, (u32*)ThisActor.SpriteBank->Palette);
int Clut=getClut(R.x,R.y);
return(Clut);
}
/*****************************************************************************/
void CActorPool::AddActor(FileEquate Filename)
{
sActorPool *Actor;
int Idx=FindActorInPool(Filename);
if (Idx!=-1) return;
// Load it
LoadActor(Filename);
}
/*****************************************************************************/
CActorGfx *CActorPool::GetActor(FileEquate Filename)
{
CActorGfx *Actor;
int Idx;
// Find Actor in Pool
Idx=FindActorInPool(Filename);
if (Idx==-1) ASSERT(!"Actor Not Loaded");
sActorPool &ThisActor=ActorPool[Idx];
Actor=new ("CActorGfx") CActorGfx;
Actor->SetData(Filename,ThisActor.SpriteBank,ThisActor.Clut);
ThisActor.RefCount++;
return(Actor);
}
/*****************************************************************************/
/*** Dump ********************************************************************/
/*****************************************************************************/
// Dumps all apart from spongeybob
void CActorPool::DumpActors()
{
for (int i=0; i<MAX_ACTORS; i++)
{
if (ActorPool[i].SpriteBank && ActorPool[i].Filename!=ACTORS_SPONGEBOB_SBK)
{
if (ActorPool[i].SpriteBank) MemFree(ActorPool[i].SpriteBank);
ActorPool[i].SpriteBank=0;
}
}
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
CActorGfx::CActorGfx()
{
}
/*****************************************************************************/
CActorGfx::~CActorGfx()
{
Dump();
}
/*****************************************************************************/
void CActorGfx::SetData(FileEquate Filename,sSpriteAnimBank *_SpriteBank,u16 _Clut)
{
SpriteBank=_SpriteBank;
Clut=_Clut;
if (Filename!=ACTORS_SPONGEBOB_SBK)
{
bool SlotStatus=SlotCache.FindSlot(_SpriteBank->MaxW,_SpriteBank->MaxH,TexX,TexY,U,V);
ASSERT(SlotStatus);
}
else
{
TexX=512;
TexY=256;
U=0;
V=0;
}
TPage=getTPage(0,0,TexX,TexY);
}
/*****************************************************************************/
void CActorGfx::ResetCache()
{
RECT R;
SlotCache.Init();
R.x=512;
R.y=256;
R.w=512;
R.h=250;
ClearImage(&R,0,255,0);
}
/*****************************************************************************/
@ -132,25 +328,26 @@ u16 ThisFrame=ThisAnim->Anim[Frame];
}
/*****************************************************************************/
POLY_FT4 *CActorGfx::Render(DVECTOR &Pos,int Anim,int Frame,bool XFlip,bool YFlip,bool Shadow)
{
sSpriteFrame *FrameGfx=GetFrame(Anim,Frame);
PAK_doUnpak(CActorPool::UnpackBuffer,FrameGfx->PAKSpr);
PAK_doUnpak(UnpackBuffer,FrameGfx->PAKSpr);
// Gfx
RECT Rect;
Rect.x=TexX;
Rect.y=TexY;
Rect.w=FrameGfx->W/4;
Rect.h=FrameGfx->H;
LoadImage( &Rect, (u32*)CActorPool::UnpackBuffer);
LoadImage( &Rect, (u32*)UnpackBuffer);
POLY_FT4 *Ft4=GetPrimFT4();
SetUpFT4(Ft4,FrameGfx,Pos.vx,Pos.vy,XFlip,YFlip);
setRGB0(Ft4,128,128,128);
setTPage(Ft4,0,0,TexX,TexY);
setClut(Ft4, ClutX, ClutY);
Ft4->tpage=TPage;
Ft4->clut=Clut;
AddPrimToList(Ft4,10);
if (Shadow)
@ -172,10 +369,8 @@ POLY_FT4 *Ft4=GetPrimFT4();
/*****************************************************************************/
void CActorGfx::SetUpFT4(POLY_FT4 *Ft4,sSpriteFrame *Frame,int X,int Y,bool XFlip,bool YFlip)
{
int U=0;
int V=4;
int W=Frame->W;
int H=Frame->H;
u8 W=Frame->W;
u8 H=Frame->H;
if (XFlip)
{
@ -218,78 +413,4 @@ int H=Frame->H;
setXYWH(Ft4,X,Y,W,H);
}
/*****************************************************************************/
void CActorGfx::Dump()
{
MemFree(SpriteBank);
}
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
void CActorPool::Init()
{
for (int i=0; i<MAX_ACTORS; i++)
{
ActorList[i]=0;
}
}
/*****************************************************************************/
int CActorPool::FindIdx(FileEquate Filename)
{
for (int i=0; i<MAX_ACTORS; i++)
{
if (ActorList[i] && ActorList[i]->GetFilename()==Filename) return(i);
}
return(-1);
}
/*****************************************************************************/
int CActorPool::FindFreeIdx()
{
for (int i=0; i<MAX_ACTORS; i++)
{
if (!ActorList[i]) return(i);
}
return(-1);
}
/*****************************************************************************/
/*** Load ********************************************************************/
/*****************************************************************************/
CActorGfx *CActorPool::GetActor(FileEquate Filename)
{
CActorGfx *NewActor;
int Idx;
// Already Loaded?
Idx=FindIdx(Filename);
if (Idx!=-1) return(ActorList[Idx]);
// Create and Load
Idx=FindFreeIdx();
ASSERT(Idx!=-1);
NewActor=new ("ActorPool") CActorGfx(Filename,Idx);
ActorList[Idx]=NewActor;
return(NewActor);
}
/*****************************************************************************/
/*** Dump ********************************************************************/
/*****************************************************************************/
// Dumps all apart from spongeybob
void CActorPool::DumpActors()
{
for (int i=0; i<MAX_ACTORS; i++)
{
if (ActorList[i] && ActorList[i]->GetFilename()!=ACTORS_SPONGEBOB_SBK)
{
CActorGfx *ThisActor=ActorList[i];
delete ThisActor;
ActorList[i]=0;
}
}
}

117
source/gfx/actor.h
View File

@ -12,39 +12,56 @@
#include <biglump.h>
#endif
/*****************************************************************************/
class CActorGfx
struct sSlot
{
public:
CActorGfx(FileEquate Filename,int No);
virtual ~CActorGfx();
void Init(FileEquate _Filename);
POLY_FT4 *Render(DVECTOR &Pos,int Anim,int Frame,bool FlipX=false,bool FlipY=false,bool Shadow=false);
void Dump();
int getFrameCount(int Anim) {return(SpriteBank->AnimList[Anim].FrameCount);}
FileEquate GetFilename() {return(Filename);}
private:
void SetUpFT4(POLY_FT4 *Ft4,sSpriteFrame *ThisFrame,int X,int Y,bool XFlip,bool YFlip);
sSpriteFrame *GetFrame(int Anim,int Frame);
FileEquate Filename;
sSpriteAnimBank *SpriteBank;
int ActorNo; // qwik bodge for mo :oP
int TexX,TexY;
int ClutX,ClutY;
u16 W,H;
};
/*****************************************************************************/
struct sActorPool
{
FileEquate Filename;
sSpriteAnimBank *SpriteBank;
u16 RefCount;
u16 Clut;
};
/*****************************************************************************/
class CSlotCache
{
public:
enum
{
DYN_W =64,
DYN_H =64,
DYN_TPAGEW =4*256,
DYN_TPAGEH =1*256,
DYN_SLOTW =(DYN_TPAGEW/DYN_W),
DYN_SLOTH =(DYN_TPAGEH/DYN_H),
DYN_SLOTX =512+256,
DYN_SLOTY =256,
};
CSlotCache(){};
~CSlotCache(){};
void Init();
bool FindSlot(int SprW,int SprH,u16 &TexX,u16 &TexY,u8 &u,u8 &v);
protected:
bool TakeSlot(int SX,int SY,int SW,int SH);
sSlot Cache[DYN_SLOTW][DYN_SLOTH];
};
/*****************************************************************************/
class CActorGfx;
class CActorPool
{
public:
enum
{
MAX_ACTORS=8,
MAX_ACTOR_SIZE=128*128,
MAX_ACTORS =32,
MAX_ACTOR_SIZE= 128*128,
};
enum ACTOR_TYPE
@ -57,21 +74,55 @@ public:
static void Init();
static void AddActor(FileEquate Filename) {GetActor(Filename);}
static CActorGfx *GetActor(FileEquate Filename);
static void DumpActors();
static void AddActor(FileEquate Filename);
static CActorGfx *GetActor(FileEquate Filename);
static void DumpActors();
static u8 UnpackBuffer[MAX_ACTOR_SIZE];
static ACTOR_TYPE getActorType( int actorNum ) {return actorType[actorNum];}
private:
static int FindIdx(FileEquate Filename);
static int FindFreeIdx();
protected:
static int FindActorInPool(FileEquate Filename);
static int FindFreeActor();
static int LoadActor(FileEquate Filename);
static u16 LoadPalette(sActorPool &ThisActor,int Idx);
static CActorGfx *ActorList[MAX_ACTORS];
static ACTOR_TYPE actorType[38];
static sActorPool ActorPool[];
static ACTOR_TYPE actorType[];
};
/*****************************************************************************/
class CActorGfx
{
public:
CActorGfx();
virtual ~CActorGfx();
void SetData(FileEquate Filename,sSpriteAnimBank *_SpriteBank,u16 _Clut);
static void ResetCache();
POLY_FT4 *Render(DVECTOR &Pos,int Anim,int Frame,bool FlipX=false,bool FlipY=false,bool Shadow=false);
int getFrameCount(int Anim) {return(SpriteBank->AnimList[Anim].FrameCount);}
protected:
void SetUpFT4(POLY_FT4 *Ft4,sSpriteFrame *ThisFrame,int X,int Y,bool XFlip,bool YFlip);
sSpriteFrame *GetFrame(int Anim,int Frame);
sSpriteAnimBank *SpriteBank;
// RECT DrawRect;
u16 Clut;
u16 TPage,TexX,TexY;
u8 U,V;
static CSlotCache SlotCache;
static u8 UnpackBuffer[CActorPool::MAX_ACTOR_SIZE];
};

2
source/level/level.cpp
View File

@ -418,7 +418,9 @@ void CLevel::init()
// Load it
sLvlTab *lvlTab=&LvlTable[s_globalLevelSelectThing];
CActorGfx::ResetCache();
CSoundMediator::setSong((CSoundMediator::SONGID)lvlTab->songId);
if (!LevelBuffer)
{
initNewLevel(lvlTab);

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

Binary file not shown.

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

@ -264,7 +264,8 @@ struct sSpriteAnimBank
u16 ColorCount; // 2
u16 AnimCount; // 2
u16 FrameCount; // 2
u16 Pad; // 2
u16 MaxW,MaxH; // 4
u16 Pad;
u8 *Palette; // 4
sSpriteAnim *AnimList; // 4