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

7
data/DataCache.scr
View file

@ -18,6 +18,13 @@ sfx/ingame.vb
sfx/ingame.vh
backdrop/credits.gfx
backdrop/sky.gfx
levels/chapter01/level01/level01.lvl
levels/chapter01/level01/level01.tex
levels/chapter01/level04/level04.lvl
levels/chapter01/level04/level04.tex
{ SYSTEM_CACHE 4
}
ui/uigfx.spr

8
makefile.gaz
View file

@ -85,10 +85,10 @@ gui_src := gbutton \
gui
level_src := level \
layer \
layertile
layertile \
layerback \
layeraction
locale_src := textdbase
mem_src := memory
@ -226,7 +226,7 @@ LINK_FILES_TO_MAKE := $(CPE_FILE) $(MAP_FILE) $(SYM_FILE)
$(LINK_FILES_TO_MAKE) : $(LINK_FILE) $(ALL_LIBS_FULL) $(CODE_OBJS_TO_MAKE)
@$(LNK) $(LNK_FLAGS) @$(LINK_FILE),$(CPE_FILE),$(SYM_FILE),$(MAP_FILE)
symmunge $(SYM_FILE)
ifeq ($(USER_NAME),daveo)
ifeq ($(USER_NAME),daveox)
@cp stats.txt '$(SIZES_DIR)/$(shell $(DATE) '+%d-%m-%Y_%H-%M-%S')'
endif

69
makefile.gfx
View file

@ -35,6 +35,37 @@ include $(BUILD_DIR)/outdirs.mak
TEMP_FILE := $(TEMP_BUILD_DIR)/build.tmp
#----------------------------------------------------------------------------
#--- Levels -----------------------------------------------------------------
#----------------------------------------------------------------------------
LEVELS_OPTS := -t:8,2,1 -s:256
LEVELS_IN_DIR := $(GRAF_DIR)/levels
LEVELS_OUT_DIR := $(DATA_OUT)/levels
LEVELS_CHAPTERS := CHAPTER01 CHAPTER02 CHAPTER03 CHAPTER04 CHAPTER05
LEVELS_CHAPTER01 := LEVEL01 LEVEL04
LEVELS_CHAPTER02 :=
LEVELS_CHAPTER03 :=
LEVELS_CHAPTER04 :=
LEVELS_CHAPTER05 :=
LEVELS_OUT_DIRS := $(foreach CHAPTER,$(LEVELS_CHAPTERS),$(foreach LEVEL,$(LEVELS_$(CHAPTER)), $(LEVELS_OUT_DIR)/$(CHAPTER)/$(LEVEL) ))
LEVELS_IN := $(foreach CHAPTER,$(LEVELS_CHAPTERS),$(foreach LEVEL,$(LEVELS_$(CHAPTER)), $(CHAPTER)/$(LEVEL)/$(LEVEL) ))
LEVELS_OUT := $(foreach LEVEL,$(LEVELS_IN),$(LEVELS_OUT_DIR)/$(LEVEL).lvl)
levels : $(LEVELS_OUT)
cleanlevels :
@$(RM) -f $(LEVELS_OUT)
@$(ECHO) Cleaned levels
$(LEVELS_OUT_DIR)/%.lvl : $(LEVELS_IN_DIR)/%.pme
@$(ECHO) Building $< $@
@$(MKLEVEL) $< -o:$(dir $(basename $@)) $(LEVELS_OPTS)
GFX_DATA_OUT += $(LEVELS_OUT)
#----------------------------------------------------------------------------
# Text translations
#----------------------------------------------------------------------------
@ -113,41 +144,6 @@ $(UI_GFX_TEX_OUT) : $(UI_GFX_TEX_IN)
GFX_DATA_OUT += $(UI_GFX_TEX_OUT)
#----------------------------------------------------------------------------
#--- Levels -----------------------------------------------------------------
#----------------------------------------------------------------------------
LEVELS_OPTS := -t:8,1,1 -s:256
LEVELS_IN_DIR := $(GRAF_DIR)/levels
LEVELS_OUT_DIR := $(DATA_OUT)/levels
LEVELS_CHAPTERS := CHAPTER01 CHAPTER02 CHAPTER03 CHAPTER04 CHAPTER05
LEVELS_CHAPTER01 := LEVEL01
LEVELS_CHAPTER02 :=
LEVELS_CHAPTER03 :=
LEVELS_CHAPTER04 :=
LEVELS_CHAPTER05 :=
LEVELS_OUT_DIRS := $(foreach CHAPTER,$(LEVELS_CHAPTERS),$(LEVELS_OUT_DIR)/$(CHAPTER))
LEVELS_ALL_LIST := $(foreach CHAPTER,$(LEVELS_CHAPTERS),$(foreach LEVEL,$(LEVELS_$(CHAPTER)), $(CHAPTER)/$(LEVEL)/$(LEVEL) ))
LEVELS_LVL_IN := $(foreach LEVEL,$(LEVELS_ALL_LIST), $(LEVELS_IN_DIR)/$(LEVEL).pme )
LEVELS_LVL_OUT := $(foreach LEVEL,$(LEVELS_ALL_LIST), $(LEVELS_OUT_DIR)/$(LEVEL).lvl )
LEVELS_ALL_IN := $(LEVELS_LVL_IN)
LEVELS_ALL_OUT := $(LEVELS_LVL_OUT)
cleanlevels :
$(RM) -f $(LEVELS_ALL_OUT)
levels: $(LEVELS_ALL_IN)
$(LEVELS_ALL_OUT) : $(LEVELS_ALL_IN)
$(MKLEVEL) $(LEVELS_ALL_IN) -o:$(LEVELS_OUT_DIR)/chapter01 $(LEVELS_OPTS)
GFX_DATA_OUT += $(LEVELS_ALL_OUT)
#----------------------------------------------------------------------------
# Ingame graphic effects
#----------------------------------------------------------------------------
@ -310,8 +306,7 @@ cleanbiglump :
@$(GLECHO) Cleaned BigLump
$(BIGLUMP_OUT) : $(BIGLUMP_IN)
# @$(MAKEDATA) -b:$(OUT_DIR)/Data/ -s:$(GAME_DATA_DIR)/DataCache.Scr -o:$(BIGLUMP_OUT) -i:$(BIGLUMP_INC)
@$(MAKEDATA) -b:$(OUT_DIR)/Data/ -s:$(GAME_DATA_DIR)/DataCache.Scr -o:$(BIGLUMP_OUT) -i:$(BIGLUMP_INC)x
@$(MAKEDATA) -b:$(OUT_DIR)/Data/ -s:$(GAME_DATA_DIR)/DataCache.Scr -o:$(BIGLUMP_OUT) -i:$(BIGLUMP_INC)
# @$(REDIR) $(TEMP_DIR)/BigLump.Scr $(BIGLUMP_IN)
# $(MAKEDATA) -b:$(OUT_DIR)/Data/ -s:$(GAME_DATA_DIR)/DataCache.Scr -s:$(TEMP_DIR)/BigLump.Scr -o:$(BIGLUMP_OUT) -i:$(BIGLUMP_INC)

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];

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

Binary file not shown.

136
tools/Data/include/dstructs.h
View file

@ -1,9 +1,10 @@
/*************************/
/*** Global Structures ***/
/*************************/
/***********************/
/*** Data Structures ***/
/***********************/
#ifndef __DATA_STRUCTS_HEADER__
#define __DATA_STRUCTS_HEADER__
#ifndef __GLOBAL_STRUCTS_HEADER__
#define __GLOBAL_STRUCTS_HEADER__
//***************************************************************************
// biped bone IDs
@ -52,9 +53,9 @@ struct sShortXYZ
struct sVtx
{
s16 vx, vy, vz, pad;
bool operator==(sVtx const &v1) {return((vx==v1.vx) && (vy==v1.vy) && (vz==v1.vz));}
#ifdef WIN32
bool operator==(sVtx const &v1) {return((vx==v1.vx) && (vy==v1.vy) && (vz==v1.vz));}
#endif
};
#define NormalScale 4096
@ -82,11 +83,12 @@ struct sMat
struct sTri
{
u16 P0,P1,P2; // 6
u16 Mat; // 2
u16 TPage; // 2
u8 uv0[2]; // 2
u8 uv1[2]; // 2
u8 uv2[2]; // 2
}; // 14
u16 Clut; // 2
}; // 16
// u8 r0, g0, b0, code; // 4
// u8 r1, g1, b1, Mat; // 4
@ -101,8 +103,8 @@ struct sQuad
u8 uv1[2]; // 2
u8 uv2[2]; // 2
u8 uv3[2]; // 2
u16 Mat; // 2
u16 Pad; // 2
u16 TPage; // 2
u16 Clut; // 2
}; // 20
// u8 r0, g0, b0, code; // 4
@ -131,27 +133,6 @@ struct sBone
//***************************************************************************
//***************************************************************************
//***************************************************************************
struct sLvlHdr
{
sTri *TriList;
sQuad *QuadList;
sVtx *VtxList;
sMat *MatList;
int LayerCount;
/*int LayerOfs[LayerCount]...*/
};
struct sLayerHdr
{
int Type;
int SubType;
int Width;
int Height;
/*int TileData[W][H];....*/
};
//---------------------------------------------------------------------------
// Tiles
struct sTileMapElem
@ -167,33 +148,82 @@ struct sTile
u16 QuadList;
u16 QuadCount;
// 2d Tile
u16 Mat2d;
s8 XOfs,YOfs;
u8 uv2d0[2];
u8 uv2d1[2];
u8 uv2d2[2];
u8 uv2d3[2];
// s16 Mat2d;
// s8 XOfs,YOfs;
u16 TPage;
u16 Clut;
u8 uv0[2];
u8 uv1[2];
u8 uv2[2];
u8 uv3[2];
BOOL operator==(sTile const &v1)
#ifdef WIN32
bool operator==(sTile const &v1)
{
if (TriCount!=v1.TriCount) return(FALSE);
if (TriList!=v1.TriList) return(FALSE);
// if (QuadCount!=v1.QuadCount) return(FALSE);
// if (QuadList!=v1.QuadList) return(FALSE);
if (TriCount!=v1.TriCount) return(false);
if (TriList!=v1.TriList) return(false);
// if (QuadCount!=v1.QuadCount) return(false);
// if (QuadList!=v1.QuadList) return(false);
if (Mat2d!=v1.Mat2d) return(FALSE);
if (uv2d0[0]!=v1.uv2d0[0]) return(FALSE);
if (uv2d0[1]!=v1.uv2d0[1]) return(FALSE);
if (uv2d1[0]!=v1.uv2d1[0]) return(FALSE);
if (uv2d1[1]!=v1.uv2d1[1]) return(FALSE);
if (uv2d2[0]!=v1.uv2d2[0]) return(FALSE);
if (uv2d2[1]!=v1.uv2d2[1]) return(FALSE);
if (uv2d3[0]!=v1.uv2d3[0]) return(FALSE);
if (uv2d3[1]!=v1.uv2d3[1]) return(FALSE);
if (TPage!=v1.TPage) return(false);
// if (Mat!=v1.Mat) return(false);
if (uv0[0]!=v1.uv0[0]) 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);
}
#endif
};
//---------------------------------------------------------------------------
// Layers
struct sLayerHdr
{
int Type;
int SubType;
int Width;
int Height;
/*int TileData[W][H];....*/
};
//---------------------------------------------------------------------------
// Header
struct sLvlHdr
{
// sTri *TriList;
// sQuad *QuadList;
// sVtx *VtxList;
// sMat *MatList;
// sTile *TileList;
// int LayerCount;
/*int LayerOfs[LayerCount]...*/
u32 TriList;
u32 QuadList;
u32 VtxList;
u32 TileList;
// Layers
u32 BackLayer;
u32 MidLayer;
u32 ActionLayer;
u32 ForeLayer;
u32 Pad0;
u32 Pad1;
u32 Pad2;
u32 Pad3;
u32 Pad4;
u32 Pad5;
u32 Pad6;
u32 Pad7;
};
#endif