kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clean Up Sprite Constant Labeling

Browse source 
Also improved struct labeling.
This commit is contained in:
gamemasterplc 2024-03-10 22:36:14 -05:00
parent d12b5c62aa
commit 504e565727
10 changed files with 434 additions and 425 deletions
Download patch file Download diff file Expand all files Collapse all files

85
include/game/animdata.h Normal file
View file

@ -0,0 +1,85 @@
#ifndef _GAME_ANIMDATA_H
#define _GAME_ANIMDATA_H
#include "dolphin.h"
#define ANIM_BMP_RGBA8 0
#define ANIM_BMP_RGB5A3 1
#define ANIM_BMP_RGB5A3_DUPE 2
#define ANIM_BMP_C8 3
#define ANIM_BMP_C4 4
#define ANIM_BMP_IA8 5
#define ANIM_BMP_IA4 6
#define ANIM_BMP_I8 7
#define ANIM_BMP_I4 8
#define ANIM_BMP_A8 9
#define ANIM_BMP_CMPR 10
#define ANIM_BMP_FMTMASK 0xF
#define ANIM_BMP_ALLOC 0x8000
#define ANIM_BMP_NUM_MASK 0x7FFF
#define ANIM_LAYER_FLIPX 0x1
#define ANIM_LAYER_FLIPY 0x2
typedef void (*SpriteFunc)(struct sprite_data *);
typedef struct anim_frame_data {
s16 pat;
s16 time;
s16 shiftX;
s16 shiftY;
s16 flip;
s16 pad;
} AnimFrameData;
typedef struct anim_bank_data {
s16 timeNum;
s16 unk;
AnimFrameData *frame;
} AnimBankData;
typedef struct anim_layer_data {
u8 alpha;
u8 flip;
s16 bmpNo;
s16 startX;
s16 startY;
s16 sizeX;
s16 sizeY;
s16 shiftX;
s16 shiftY;
s16 vtx[8];
} AnimLayerData;
typedef struct anim_pat_data {
s16 layerNum;
s16 centerX;
s16 centerY;
s16 sizeX;
s16 sizeY;
AnimLayerData *layer;
} AnimPatData;
typedef struct anim_bmp_data {
u8 pixSize;
u8 dataFmt;
s16 palNum;
s16 sizeX;
s16 sizeY;
u32 dataSize;
void *palData;
void *data;
} AnimBmpData;
typedef struct anim_data {
s16 bankNum;
s16 patNum;
s16 bmpNum;
s16 useNum;
AnimBankData *bank;
AnimPatData *pat;
AnimBmpData *bmp;
} AnimData;
#endif

221
include/game/sprite.h
View file

@ -5,111 +5,36 @@
#include "game/data.h"
#include "game/memory.h"
#define SPRITE_MAX 384
#define SPRITE_GROUP_MAX 256
#define HUSPR_MAX 384
#define HUSPR_GRP_MAX 256
#define SPRITE_INVALID -1
#define SPRITE_GROUP_INVALID -1
#define HUSPR_NONE -1
#define HUSPR_GRP_NONE -1
#define SPRITE_ATTR_PAUSED 0x1
#define SPRITE_ATTR_LOOP 0x2
#define SPRITE_ATTR_HIDDEN 0x4
#define SPRITE_ATTR_BILINEAR 0x8
#define SPRITE_ATTR_FUNC 0x10
#define SPRITE_ATTR_NOPAUSE 0x20
#define SPRITE_ATTR_REVERSE 0x40
#define SPRITE_ATTR_ADDITIVE 0x80
#define SPRITE_ATTR_INVERT 0x100
#define HUSPR_ATTR_NOANIM 0x1
#define HUSPR_ATTR_LOOP 0x2
#define HUSPR_ATTR_DISPOFF 0x4
#define HUSPR_ATTR_LINEAR 0x8
#define HUSPR_ATTR_FUNC 0x10
#define HUSPR_ATTR_NOPAUSE 0x20
#define HUSPR_ATTR_REVERSE 0x40
#define HUSPR_ATTR_ADDCOL 0x80
#define HUSPR_ATTR_INVCOL 0x100
#define SPRITE_BMP_RGBA8 0
#define SPRITE_BMP_RGB5A3 1
#define SPRITE_BMP_RGB5A3_DUPE 2
#define SPRITE_BMP_C8 3
#define SPRITE_BMP_C4 4
#define SPRITE_BMP_IA8 5
#define SPRITE_BMP_IA4 6
#define SPRITE_BMP_I8 7
#define SPRITE_BMP_I4 8
#define SPRITE_BMP_A8 9
#define SPRITE_BMP_CMPR 10
#include "game/animdata.h"
#define SPRITE_BMP_FMTMASK 0xF
#define SPRITE_BMP_ALLOC 0x8000
#define SPRITE_BMP_NUM_MASK 0x7FFF
typedef void (*HuSprFunc)(struct hu_sprite *);
#define SPRITE_LAYER_FLIPX 0x1
#define SPRITE_LAYER_FLIPY 0x2
typedef void (*SpriteFunc)(struct sprite_data *);
typedef struct anim_frame_data {
s16 pat;
s16 time;
s16 shiftX;
s16 shiftY;
s16 flip;
s16 pad;
} AnimFrameData;
typedef struct anim_bank_data {
s16 timeNum;
s16 unk;
AnimFrameData *frame;
} AnimBankData;
typedef struct anim_layer_data {
u8 alpha;
u8 flip;
s16 bmpNo;
s16 startX;
s16 startY;
s16 sizeX;
s16 sizeY;
s16 shiftX;
s16 shiftY;
s16 vtx[8];
} AnimLayerData;
typedef struct anim_pat_data {
s16 layerNum;
s16 centerX;
s16 centerY;
s16 sizeX;
s16 sizeY;
AnimLayerData *layer;
} AnimPatData;
typedef struct anim_bmp_data {
u8 pixSize;
u8 dataFmt;
s16 palNum;
s16 sizeX;
s16 sizeY;
u32 dataSize;
void *palData;
void *data;
} AnimBmpData;
typedef struct anim_data {
s16 bankNum;
s16 patNum;
s16 bmpNum;
s16 useNum;
AnimBankData *bank;
AnimPatData *pat;
AnimBmpData *bmp;
} AnimData;
typedef struct sprite_data {
typedef struct hu_sprite {
u8 r;
u8 g;
u8 b;
char draw_no;
short frame;
short bank;
short attr;
short dirty_flag;
short prio;
u8 draw_no;
s16 frame;
s16 bank;
s16 attr;
s16 dirty_flag;
s16 prio;
float time;
float x;
float y;
@ -120,26 +45,26 @@ typedef struct sprite_data {
float a;
GXTexWrapMode wrap_s;
GXTexWrapMode wrap_t;
short tex_scale_x;
short tex_scale_y;
s16 tex_scale_x;
s16 tex_scale_y;
Mtx *group_mtx;
union {
AnimData *data;
SpriteFunc func;
HuSprFunc func;
};
AnimPatData *pat_data;
AnimFrameData *frame_data;
short work[4];
s16 work[4];
AnimData *bg;
unsigned short bg_bank;
short scissor_x;
short scissor_y;
short scissor_w;
short scissor_h;
} SpriteData;
u16 bg_bank;
s16 scissor_x;
s16 scissor_y;
s16 scissor_w;
s16 scissor_h;
} HuSprite;
typedef struct sprite_group_data {
short capacity;
typedef struct hu_spr_grp {
s16 capacity;
float x;
float y;
float z_rot;
@ -147,60 +72,60 @@ typedef struct sprite_group_data {
float scale_y;
float center_x;
float center_y;
short *members;
s16 *members;
Mtx mtx;
} SpriteGroupData;
} HuSprGrp;
extern SpriteData HuSprData[SPRITE_MAX];
extern SpriteGroupData HuSprGrpData[SPRITE_GROUP_MAX];
extern HuSprite HuSprData[HUSPR_MAX];
extern HuSprGrp HuSprGrpData[HUSPR_GRP_MAX];
#define HuSprAnimReadFile(data_id) (HuSprAnimRead(HuDataSelHeapReadNum((data_id), MEMORY_DEFAULT_NUM, HEAP_DATA)))
void HuSprInit(void);
void HuSprClose(void);
void HuSprExec(short draw_no);
void HuSprExec(s16 draw_no);
void HuSprBegin(void);
SpriteData *HuSprCall(void);
HuSprite *HuSprCall(void);
void HuSprFinish(void);
void HuSprPauseSet(BOOL value);
AnimData *HuSprAnimRead(void *data);
void HuSprAnimLock(AnimData *anim);
short HuSprCreate(AnimData *anim, short prio, short bank);
short HuSprFuncCreate(SpriteFunc func, short prio);
short HuSprGrpCreate(short capacity);
short HuSprGrpCopy(short group);
void HuSprGrpMemberSet(short group, short member, short sprite);
void HuSprGrpMemberKill(short group, short member);
void HuSprGrpKill(short group);
void HuSprKill(short sprite);
s16 HuSprCreate(AnimData *anim, s16 prio, s16 bank);
s16 HuSprFuncCreate(HuSprFunc func, s16 prio);
s16 HuSprGrpCreate(s16 capacity);
s16 HuSprGrpCopy(s16 group);
void HuSprGrpMemberSet(s16 group, s16 member, s16 sprite);
void HuSprGrpMemberKill(s16 group, s16 member);
void HuSprGrpKill(s16 group);
void HuSprKill(s16 sprite);
void HuSprAnimKill(AnimData *anim);
void HuSprAttrSet(short group, short member, int attr);
void HuSprAttrReset(short group, short member, int attr);
void HuSprPosSet(short group, short member, float x, float y);
void HuSprZRotSet(short group, short member, float z_rot);
void HuSprScaleSet(short group, short member, float x, float y);
void HuSprTPLvlSet(short group, short member, float tp_lvl);
void HuSprColorSet(short group, short member, u8 r, u8 g, u8 b);
void HuSprSpeedSet(short group, short member, float speed);
void HuSprBankSet(short group, short member, short bank);
void HuSprGrpPosSet(short group, float x, float y);
void HuSprGrpCenterSet(short group, float x, float y);
void HuSprGrpZRotSet(short group, float z_rot);
void HuSprGrpScaleSet(short group, float x, float y);
void HuSprGrpTPLvlSet(short group, float tp_lvl);
s32 HuSprGrpDrawNoSet(short group, int draw_no);
void HuSprDrawNoSet(short group, short member, int draw_no);
void HuSprPriSet(short group, short member, short prio);
void HuSprGrpScissorSet(short group, short x, short y, short w, short h);
void HuSprScissorSet(short group, short member, short x, short y, short w, short h);
AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt);
void HuSprBGSet(short group, short member, AnimData *bg, short bg_bank);
void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank);
void HuSprAttrSet(s16 group, s16 member, s32 attr);
void HuSprAttrReset(s16 group, s16 member, s32 attr);
void HuSprPosSet(s16 group, s16 member, float x, float y);
void HuSprZRotSet(s16 group, s16 member, float z_rot);
void HuSprScaleSet(s16 group, s16 member, float x, float y);
void HuSprTPLvlSet(s16 group, s16 member, float tp_lvl);
void HuSprColorSet(s16 group, s16 member, u8 r, u8 g, u8 b);
void HuSprSpeedSet(s16 group, s16 member, float speed);
void HuSprBankSet(s16 group, s16 member, s16 bank);
void HuSprGrpPosSet(s16 group, float x, float y);
void HuSprGrpCenterSet(s16 group, float x, float y);
void HuSprGrpZRotSet(s16 group, float z_rot);
void HuSprGrpScaleSet(s16 group, float x, float y);
void HuSprGrpTPLvlSet(s16 group, float tp_lvl);
s32 HuSprGrpDrawNoSet(s16 group, s32 draw_no);
void HuSprDrawNoSet(s16 group, s16 member, s32 draw_no);
void HuSprPriSet(s16 group, s16 member, s16 prio);
void HuSprGrpScissorSet(s16 group, s16 x, s16 y, s16 w, s16 h);
void HuSprScissorSet(s16 group, s16 member, s16 x, s16 y, s16 w, s16 h);
AnimData *HuSprAnimMake(s16 sizeX, s16 sizeY, s16 dataFmt);
void HuSprBGSet(s16 group, s16 member, AnimData *bg, s16 bg_bank);
void HuSprSprBGSet(s16 sprite, AnimData *bg, s16 bg_bank);
void AnimDebug(AnimData *anim);
void HuSprDispInit(void);
void HuSprDisp(SpriteData *sprite);
void HuSprTexLoad(AnimData *anim, short bmp, short slot, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, GXTexFilter filter);
void HuSprExecLayerSet(short draw_no, short layer);
void HuSprDisp(HuSprite *sprite);
void HuSprTexLoad(AnimData *anim, s16 bmp, s16 slot, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, GXTexFilter filter);
void HuSprExecLayerSet(s16 draw_no, s16 layer);
#endif

48
src/REL/bootDll/main.c
View file

@ -84,14 +84,14 @@ static void BootProc(void)
sprite_nintendo = HuSprCreate(data, 0, 0);
HuSprGrpMemberSet(group, 0, sprite_nintendo);
HuSprPosSet(group, 0, 288, 240);
HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
if(omovlevtno != 0) {
HuAudSndGrpSetSet(0);
data = HuSprAnimReadFile(TITLE_HUDSON_ANM);
sprite_hudson = HuSprCreate(data, 0, 0);
HuSprGrpMemberSet(group, 1, sprite_hudson);
HuSprPosSet(group, 1, 288, 240);
HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
HuWinInit(1);
TitleInit();
SystemInitF = 1;
@ -104,7 +104,7 @@ static void BootProc(void)
GWPlayerCfg[i].pad_idx = i;
}
repeat:
HuSprAttrReset(group, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(group, 0, HUSPR_ATTR_DISPOFF);
WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);
while(WipeStatGet()) {
HuPrcVSleep();
@ -121,7 +121,7 @@ static void BootProc(void)
sprite_hudson = HuSprCreate(data, 0, 0);
HuSprGrpMemberSet(group, 1, sprite_hudson);
HuSprPosSet(group, 1, 288, 240);
HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
while(OSTicksToMilliseconds(OSGetTick()-tick_prev) < 3000) {
HuPrcVSleep();
}
@ -137,8 +137,8 @@ static void BootProc(void)
while(WipeStatGet()) {
HuPrcVSleep();
}
HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
HuSprAttrReset(group, 1, HUSPR_ATTR_DISPOFF);
HuPrcSleep(60);
WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);
while(WipeStatGet()) {
@ -173,8 +173,8 @@ static void BootProc(void)
while(OSTicksToMilliseconds(OSGetTick()-tick_prev) < 1000) {
HuPrcVSleep();
}
HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
group_thp = HuSprGrpCreate(1);
sprite_thp = HuTHPSprCreateVol("movie/opmov_a00.thp", 0, 100, 122);
HuSprGrpMemberSet(group_thp, 0, sprite_thp);
@ -300,7 +300,7 @@ static void ProgressiveProc(void)
sprite = HuSprCreate(data, 0, 0);
HuSprGrpMemberSet(group, 2, sprite);
HuSprPosSet(group, 2, progressivePosTbl[option*2], progressivePosTbl[(option*2)+1]);
HuSprAttrSet(group, 2, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 2, HUSPR_ATTR_DISPOFF);
WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);
while(WipeStatGet()) {
HuPrcVSleep();
@ -312,9 +312,9 @@ static void ProgressiveProc(void)
i=0;
}
if(HU_PAD_BTNDOWN_ALL & PAD_BUTTON_A) {
HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
HuSprPosSet(group, 2, progressivePosTbl[option*2], progressivePosTbl[(option*2)+1]);
HuSprAttrReset(group, 2, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(group, 2, HUSPR_ATTR_DISPOFF);
break;
}
HuPrcVSleep();
@ -468,23 +468,23 @@ static void TitleInit(void)
sprite_data = HuSprAnimReadFile(TITLE_BG_ANM);
sprite = HuSprCreate(sprite_data, 0, 0);
HuSprGrpMemberSet(titleGroup, 0, sprite);
HuSprAttrSet(titleGroup, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 0, HUSPR_ATTR_DISPOFF);
HuSprDrawNoSet(titleGroup, 0, 127);
HuSprPosSet(titleGroup, 0, 288, 240);
sprite_data = HuSprAnimReadFile(TITLE_COPYRIGHT_ANM);
sprite = HuSprCreate(sprite_data, 1, 0);
HuSprGrpMemberSet(titleGroup, 1, sprite);
HuSprAttrSet(titleGroup, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 1, HUSPR_ATTR_DISPOFF);
HuSprPosSet(titleGroup, 1, 288, 420);
sprite_data = HuSprAnimReadFile(TITLE_PRESS_START_ANM);
sprite = HuSprCreate(sprite_data, 2, 0);
HuSprGrpMemberSet(titleGroup, 2, sprite);
HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN|SPRITE_ATTR_BILINEAR);
HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF|HUSPR_ATTR_LINEAR);
HuSprPosSet(titleGroup, 2, 288, 380);
sprite_data = HuSprAnimReadFile(TITLE_LOGO_ANM);
sprite = HuSprCreate(sprite_data, 0, 0);
HuSprGrpMemberSet(titleGroup, 3, sprite);
HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN|SPRITE_ATTR_BILINEAR);
HuSprAttrSet(titleGroup, 3, HUSPR_ATTR_DISPOFF|HUSPR_ATTR_LINEAR);
HuSprPosSet(titleGroup, 3, 288, 200);
}
@ -496,8 +496,8 @@ static BOOL TitleProc(void)
s16 i;
Hu3DModelAttrReset(titleModel[0], 1);
Hu3DModelAttrReset(titleModel[1], 1);
HuSprAttrReset(titleGroup, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(titleGroup, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(titleGroup, 0, HUSPR_ATTR_DISPOFF);
HuSprAttrReset(titleGroup, 1, HUSPR_ATTR_DISPOFF);
OSReport(">>>>>>>>MSM_SE_SEL_01 %d\n", msmSeGetEntryID(2092, y_offset));
OSReport(">>>>>>>>SE Num %d\n", msmSeGetNumPlay(0));
HuAudSStreamPlay(20);
@ -505,14 +505,14 @@ static BOOL TitleProc(void)
while(WipeStatGet()) {
HuPrcVSleep();
}
HuSprAttrReset(titleGroup, 3, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(titleGroup, 3, HUSPR_ATTR_DISPOFF);
for(i=1; i<=50; i++) {
scale = (cos((i*1.8)*M_PI/180.0)*10.0)+1.0;
HuSprScaleSet(titleGroup, 3, scale, scale);
HuSprTPLvlSet(titleGroup, 3, i/50.0);
HuPrcVSleep();
}
HuSprAttrReset(titleGroup, 2, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(titleGroup, 2, HUSPR_ATTR_DISPOFF);
for(i=scale_time=0; i<1800; i++) {
if(i <= 10) {
HuSprTPLvlSet(titleGroup, 2, i/10.0);
@ -522,7 +522,7 @@ static BOOL TitleProc(void)
if(ret < 0) {
OSReport(">>>>>Error %d\n", ret);
}
HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF);
return 1;
}
scale = (sin((i*scale_time)*M_PI/180.0)*0.1)+0.9;
@ -541,10 +541,10 @@ static BOOL TitleProc(void)
Hu3DModelAttrSet(titleModel[0], 1);
Hu3DModelAttrSet(titleModel[1], 1);
Hu3DModelAttrSet(titleModel[2], 1);
HuSprAttrSet(titleGroup, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(titleGroup, 0, HUSPR_ATTR_DISPOFF);
HuSprAttrSet(titleGroup, 1, HUSPR_ATTR_DISPOFF);
HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF);
HuSprAttrSet(titleGroup, 3, HUSPR_ATTR_DISPOFF);
return 0;
}

14
src/game/board/main.c
View file

@ -2018,17 +2018,17 @@ void BoardLast5GfxInit(void)
}
BoardSpriteCreate(spr_file, prio, NULL, &work->sprites[i]);
HuSprGrpMemberSet(work->group, i, work->sprites[i]);
HuSprAttrSet(work->group, i, SPRITE_ATTR_BILINEAR);
HuSprAttrSet(work->group, i, HUSPR_ATTR_LINEAR);
HuSprPosSet(work->group, i, last5GfxPosTbl[lastF][i][0], last5GfxPosTbl[lastF][i][1]);
}
if(!work->is_last) {
SpriteData *sprite = &HuSprData[HuSprGrpData[work->group].members[1]];
HuSprite *sprite = &HuSprData[HuSprGrpData[work->group].members[1]];
HuSprBankSet(work->group, 1, 0);
sprite->frame = turn_remain;
} else {
HuSprAttrSet(work->group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->group, 1, HUSPR_ATTR_DISPOFF);
}
HuSprAttrSet(work->group, 1, SPRITE_ATTR_PAUSED);
HuSprAttrSet(work->group, 1, HUSPR_ATTR_NOANIM);
object->trans.x = 0.0f;
HuSprGrpTPLvlSet(work->group, object->trans.x);
HuSprGrpPosSet(work->group, 288, 72);
@ -2105,12 +2105,12 @@ void BoardLast5GfxShowSet(s32 show)
work = OM_GET_WORK_PTR(last5GfxObj, Last5GfxWork);
for(i=0; i<3; i++) {
if(show) {
HuSprAttrReset(work->group, i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->group, i, HUSPR_ATTR_DISPOFF);
} else {
HuSprAttrSet(work->group, i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->group, i, HUSPR_ATTR_DISPOFF);
}
if(work->is_last) {
HuSprAttrSet(work->group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->group, 1, HUSPR_ATTR_DISPOFF);
}
}
}

12
src/game/board/space.c
View file

@ -1000,15 +1000,15 @@ void BoardSpaceInit(s32 data_num)
size = bmp->sizeX;
spaceHiliteTexFmt = -1;
switch(bmp->dataFmt) {
case SPRITE_BMP_RGBA8:
case ANIM_BMP_RGBA8:
spaceHiliteTexFmt = GX_TF_RGBA8;
break;
case SPRITE_BMP_RGB5A3_DUPE:
case ANIM_BMP_RGB5A3_DUPE:
spaceHiliteTexFmt = GX_TF_RGB5A3;
break;
case SPRITE_BMP_CMPR:
case ANIM_BMP_CMPR:
spaceHiliteTexFmt = GX_TF_CMPR;
break;
}
@ -1032,15 +1032,15 @@ void BoardSpaceInit(s32 data_num)
size = bmp->sizeX;
spaceTexFmt = -1;
switch(bmp->dataFmt) {
case SPRITE_BMP_RGBA8:
case ANIM_BMP_RGBA8:
spaceTexFmt = GX_TF_RGBA8;
break;
case SPRITE_BMP_RGB5A3_DUPE:
case ANIM_BMP_RGB5A3_DUPE:
spaceTexFmt = GX_TF_RGB5A3;
break;
case SPRITE_BMP_CMPR:
case ANIM_BMP_CMPR:
spaceTexFmt = GX_TF_CMPR;
break;
}

84
src/game/minigame_seq.c
View file

@ -428,7 +428,7 @@ static int SeqInitTimer(SeqWork *work, va_list params)
if(seqPauseF) {
work->work_s16[1] = 1;
for(i=0; i<2; i++) {
HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
(void)i; //Hack for Matching
}
}
@ -497,7 +497,7 @@ static int SeqUpdateTimer(SeqWork *work)
case 3:
for(i=0; i<2; i++) {
HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
}
work->work_s16[1] = 3;
work->param[0] = 0;
@ -684,7 +684,7 @@ static int SeqInitType2(SeqWork *work, va_list params)
if(seqPauseF) {
work->work_s16[1] = 1;
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
}
}
return 1;
@ -718,7 +718,7 @@ static int SeqUpdateType2(SeqWork *work)
{
s32 i;
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
(void)i;
}
work->work_s16[1] = 0;
@ -988,7 +988,7 @@ static int SeqInitMGBasic(SeqWork *work, va_list params)
}
if(seqPauseF) {
work->type = 2;
HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
} else {
work->param[0] = 3;
}
@ -1091,14 +1091,14 @@ static int SeqUpdateMGBasic(SeqWork *work)
time = work->time;
scale = work->scale_x+(0.5*sin(((time*9.0f)*M_PI)/180.0));
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(i*56));
HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
HuSprScaleSet(work->spr_grp[0], i, work->scale_x+sin(((time*9.0f)*M_PI)/180.0), work->scale_y+sin(((time*9.0f)*M_PI)/180.0));
}
if(time == 20.0f) {
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
}
}
} else {
@ -1110,7 +1110,7 @@ static int SeqUpdateMGBasic(SeqWork *work)
}
pos_x = (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56);
if(time == 20.0f) {
HuSprAttrSet(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
} else {
HuSprPosSet(work->spr_grp[0], i, pos_x+((1.0-cos(((time*4.5f)*M_PI)/180.0f))*(work->work_s16[3]*56*2)), work->y);
HuSprZRotSet(work->spr_grp[0], i, (time/20.0f)*390.0f);
@ -1215,7 +1215,7 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
HuSprTPLvlSet(work->spr_grp[word_grp], j, tp_lvl);
HuSprPosSet(work->spr_grp[word_grp], j, -100.0f, 240.0f);
HuSprPriSet(work->spr_grp[word_grp], j, i+5);
HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
}
if(i == 0) {
tp_lvl -= 0.5;
@ -1225,7 +1225,7 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
}
if(seqPauseF) {
work->type = 2;
HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
} else {
work->param[0] = 3;
}
@ -1302,7 +1302,7 @@ static int SeqUpdateMGBattle(SeqWork *work)
HuSprZRotSet(work->spr_grp[i], j, 0.0f);
HuSprScaleSet(work->spr_grp[i], j, work->scale_x, work->scale_y);
if(i != 0) {
HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
} else {
s16 discard_cnt;
@ -1383,20 +1383,20 @@ static int SeqUpdateMGBattle(SeqWork *work)
if(work->time <= 20) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
time = work->time;
scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
}
if(time == 20.0f) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
}
}
} else {
@ -1408,7 +1408,7 @@ static int SeqUpdateMGBattle(SeqWork *work)
}
if(time == 15.0f) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[1], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
HuSprPosSet(work->spr_grp[1], j, 288.0f, work->y);
HuSprTPLvlSet(work->spr_grp[1], j, 1.0f);
}
@ -1560,7 +1560,7 @@ static int SeqUpdateMG1vs3(SeqWork *work)
if(work->time == 60) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
}
@ -1600,13 +1600,13 @@ static int SeqUpdateMG1vs3(SeqWork *work)
if(work->time <= 20) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
time = work->time;
scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@ -1614,7 +1614,7 @@ static int SeqUpdateMG1vs3(SeqWork *work)
if(time == 20.0f) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
}
@ -1746,7 +1746,7 @@ static int SeqUpdateMGStory(SeqWork *work)
}
if(work->time == 30) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrSet(work->spr_grp[1], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
}
}
} else {
@ -1792,13 +1792,13 @@ static int SeqUpdateMGStory(SeqWork *work)
if(work->time <= 20) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
time = work->time;
scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@ -1806,7 +1806,7 @@ static int SeqUpdateMGStory(SeqWork *work)
if(time == 20.0f){
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
}
@ -1988,13 +1988,13 @@ static int SeqUpdateMG2vs2(SeqWork *work)
if(work->time <= 20) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
time = work->time;
scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@ -2002,7 +2002,7 @@ static int SeqUpdateMG2vs2(SeqWork *work)
if(time == 20.0f) {
for(i=1; i<4; i++) {
for(j=0; j<work->work_s16[3]; j++) {
HuSprAttrReset(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
}
}
}
@ -2102,8 +2102,8 @@ static int SeqInitFlip(SeqWork *work, va_list params)
for(i=0; i<work->work_s16[3]; i++) {
HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
HuSprPosSet(work->spr_grp[word_grp], i, (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56), work->y);
HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
HuSprAttrReset(work->spr_grp[word_grp], i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
}
work->work_s16[2] = work->work_s16[3];
{
@ -2133,12 +2133,12 @@ static int SeqInitFlip(SeqWork *work, va_list params)
for(i=0; i<work->work_s16[3]; i++) {
HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
HuSprPosSet(work->spr_grp[word_grp], i, (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56), work->y);
HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
HuSprAttrReset(work->spr_grp[word_grp], i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
}
if(seqPauseF) {
work->type = 2;
HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
} else {
work->param[0] = 3;
}
@ -2445,13 +2445,13 @@ static int SeqUpdateMGBowser(SeqWork *work)
if(work->time <= 20) {
for(j=1; j<4; j++) {
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrSet(work->spr_grp[j], i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
}
}
time = work->time;
scale = work->scale_x+(0.5*sin(((time*9.0f)*M_PI)/180.0));
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(i*56));
HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
HuSprScaleSet(work->spr_grp[0], i, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@ -2459,7 +2459,7 @@ static int SeqUpdateMGBowser(SeqWork *work)
if(time == 20.0f) {
for(j=1; j<4; j++) {
for(i=0; i<work->work_s16[3]; i++) {
HuSprAttrReset(work->spr_grp[j], i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
}
}
}
@ -2754,7 +2754,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
winnerNameW[0] = work->work_s16[3]*50;
for(i=0; i<work->work_s16[3]; i++) {
HuSprPosSet(work->spr_grp[word_grp], i, 25.0f+((i*50)-(0.5f*(work->work_s16[3]*50))), 0.0f);
HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
}
num_winners = 0;
work->work_float[1] = 1.0f;
@ -2778,7 +2778,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
word_x = 0.0f;
for(i=word_x; i<work->work_s16[3]; i++, name++) {
HuSprPosSet(work->spr_grp[word_grp], i, 25.0+(word_x-(0.5*word_w)), 0.0f);
HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
if(*name == ' ') {
word_x += 30.0f;
} else {
@ -2795,7 +2795,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
if(winner == 7 || winner == 13) {
for(i=0;i<work->work_s16[3]; i++) {
HuSprPosSet(work->spr_grp[word_grp], i, 26.0f+((i*52)-(0.5f*(work->work_s16[3]*52))), 0.0f);
HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
}
work->work_float[1] = 0.8f;
winnerNameW[num_winners+1] = work->work_s16[3]*52;
@ -2844,7 +2844,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
work->type = 1;
num_winners++;
for(j=0; j<num_winners; j++) {
HuSprAttrSet(work->spr_grp[j], 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->spr_grp[j], 0, HUSPR_ATTR_DISPOFF);
}
} else {
work->param[0] = 3;
@ -3028,7 +3028,7 @@ static int SeqInitRecord(SeqWork *work, va_list params)
HuSprBankSet(spr_grp, digit_idx+2, seqRecordVal);
digit_idx++;
for(i=digit_idx; i<8; i++) {
HuSprAttrSet(spr_grp, i+2, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(spr_grp, i+2, HUSPR_ATTR_DISPOFF);
}
HuSprPosSet(spr_grp, 1, (-((digit_idx*44)+48)/2)+24, 32.0f);
for(i=0; i<digit_idx; i++) {
@ -3073,7 +3073,7 @@ static int SeqInitRecord(SeqWork *work, va_list params)
HuSprBankSet(spr_grp, digit_idx+2, seqRecordVal);
digit_idx++;
for(i=digit_idx; i<8; i++) {
HuSprAttrSet(spr_grp, i+2, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(spr_grp, i+2, HUSPR_ATTR_DISPOFF);
}
HuSprPosSet(spr_grp, 1, (-((digit_idx*44)+4)/2)+24, 32.0f);
x = (-((digit_idx*44)+4)/2)+70;
@ -3444,11 +3444,11 @@ static void PracticeProc(void)
HuSprPosSet(group, 0, 288.0f, yPosTbl[practice[1]]);
do {
if(!wipeFadeInF || WipeStatGet()) {
HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
HuPrcVSleep();
continue;
}
HuSprAttrReset(group, 0, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(group, 0, HUSPR_ATTR_DISPOFF);
for(i=0; i<4; i++) {
if(!(HuPadBtnDown[GWPlayerCfg[i].pad_idx] & PAD_TRIGGER_Z)) {
continue;;

327
src/game/sprman.c
View file

@ -8,34 +8,33 @@
#define SPRITE_DIRTY_XFORM 0x2
#define SPRITE_DIRTY_COLOR 0x4
typedef struct sprite_order_data {
unsigned short group;
unsigned short sprite;
unsigned short prio;
unsigned short next;
} SpriteOrderData;
typedef struct sprite_order {
u16 group;
u16 sprite;
u16 prio;
u16 next;
} SpriteOrder;
SpriteData HuSprData[SPRITE_MAX];
SpriteGroupData HuSprGrpData[SPRITE_GROUP_MAX];
static SpriteOrderData HuSprOrder[SPRITE_MAX*2];
HuSprite HuSprData[HUSPR_MAX];
HuSprGrp HuSprGrpData[HUSPR_GRP_MAX];
static SpriteOrder HuSprOrder[HUSPR_MAX*2];
static short HuSprOrderNum;
static short HuSprOrderNo;
static s16 HuSprOrderNum;
static s16 HuSprOrderNo;
static BOOL HuSprPauseF;
static void HuSprOrderEntry(short group, short sprite);
static void HuSprOrderEntry(s16 group, s16 sprite);
void mtxTransCat(Mtx matrix, float x, float y, int z); //Last argument should be a float
void HuSprInit(void)
{
short i;
SpriteData *sprite;
SpriteGroupData *group;
for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
s16 i;
HuSprite *sprite;
HuSprGrp *group;
for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
sprite->data = NULL;
}
for(group = HuSprGrpData, i=0; i<SPRITE_GROUP_MAX; i++, group++) {
for(group = HuSprGrpData, i=0; i<HUSPR_GRP_MAX; i++, group++) {
group->capacity = 0;
}
sprite = &HuSprData[0];
@ -46,16 +45,16 @@ void HuSprInit(void)
void HuSprClose(void)
{
short i;
SpriteGroupData *group;
SpriteData *sprite;
s16 i;
HuSprGrp *group;
HuSprite *sprite;
for(group = HuSprGrpData, i=0; i<SPRITE_GROUP_MAX; i++, group++) {
for(group = HuSprGrpData, i=0; i<HUSPR_GRP_MAX; i++, group++) {
if(group->capacity != 0) {
HuSprGrpKill(i);
}
}
for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
if(sprite->data) {
HuSprKill(i);
}
@ -63,11 +62,11 @@ void HuSprClose(void)
HuSprPauseF = FALSE;
}
void HuSprExec(short draw_no)
void HuSprExec(s16 draw_no)
{
SpriteData *sprite;
HuSprite *sprite;
while(sprite = HuSprCall()) {
if(!(sprite->attr & SPRITE_ATTR_HIDDEN) && sprite->draw_no == draw_no) {
if(!(sprite->attr & HUSPR_ATTR_DISPOFF) && sprite->draw_no == draw_no) {
HuSprDisp(sprite);
}
}
@ -76,14 +75,14 @@ void HuSprExec(short draw_no)
void HuSprBegin(void)
{
Mtx temp, rot;
short i, j;
s16 i, j;
Vec axis = {0, 0, 1};
SpriteGroupData *group;
HuSprGrp *group;
group = HuSprGrpData;
HuSprOrderNum = 1;
HuSprOrder[0].next = 0;
HuSprOrder[0].prio = -1;
for(i=0; i<SPRITE_GROUP_MAX; i++, group++) {
for(i=0; i<HUSPR_GRP_MAX; i++, group++) {
if(group->capacity != 0) {
MTXTrans(temp, group->center_x*group->scale_x, group->center_y*group->scale_y, 0.0f);
MTXRotAxisDeg(rot, &axis, group->z_rot);
@ -101,12 +100,12 @@ void HuSprBegin(void)
HuSprOrderNo = 0;
}
static void HuSprOrderEntry(short group, short sprite)
static void HuSprOrderEntry(s16 group, s16 sprite)
{
SpriteOrderData *order = &HuSprOrder[HuSprOrderNum];
short prio = HuSprData[sprite].prio;
short prev, next;
if(HuSprOrderNum >= SPRITE_MAX*2) {
SpriteOrder *order = &HuSprOrder[HuSprOrderNum];
s16 prio = HuSprData[sprite].prio;
s16 prev, next;
if(HuSprOrderNum >= HUSPR_MAX*2) {
OSReport("Order Max Over!\n");
return;
}
@ -124,14 +123,14 @@ static void HuSprOrderEntry(short group, short sprite)
HuSprOrderNum++;
}
SpriteData *HuSprCall(void)
HuSprite *HuSprCall(void)
{
HuSprOrderNo = HuSprOrder[HuSprOrderNo].next;
if(HuSprOrderNo != 0) {
SpriteOrderData *order = &HuSprOrder[HuSprOrderNo];
SpriteData *sprite = &HuSprData[order->sprite];
SpriteOrder *order = &HuSprOrder[HuSprOrderNo];
HuSprite *sprite = &HuSprData[order->sprite];
sprite->group_mtx = &HuSprGrpData[order->group].mtx;
if(sprite->attr & SPRITE_ATTR_FUNC) {
if(sprite->attr & HUSPR_ATTR_FUNC) {
return sprite;
}
sprite->frame_data = &sprite->data->bank[sprite->bank].frame[sprite->frame];
@ -142,7 +141,7 @@ SpriteData *HuSprCall(void)
}
}
static inline void SpriteCalcFrame(SpriteData *sprite, AnimBankData *bank, AnimFrameData **frame, short loop)
static inline void SpriteCalcFrame(HuSprite *sprite, AnimBankData *bank, AnimFrameData **frame, s16 loop)
{
if(sprite->time >= (*frame)->time) {
sprite->frame++;
@ -174,22 +173,22 @@ void HuSprFinish(void)
AnimData *anim;
AnimBankData *bank;
AnimFrameData *frame;
SpriteData *sprite;
short i;
short j;
short loop;
short dir;
HuSprite *sprite;
s16 i;
s16 j;
s16 loop;
s16 dir;
for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
if(sprite->data && !(sprite->attr & SPRITE_ATTR_FUNC)) {
if(!HuSprPauseF || (sprite->attr & SPRITE_ATTR_NOPAUSE)) {
for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
if(sprite->data && !(sprite->attr & HUSPR_ATTR_FUNC)) {
if(!HuSprPauseF || (sprite->attr & HUSPR_ATTR_NOPAUSE)) {
anim = sprite->data;
bank = &anim->bank[sprite->bank];
frame = &bank->frame[sprite->frame];
loop = (sprite->attr & SPRITE_ATTR_LOOP) ? 0 : 1;
if(!(sprite->attr & SPRITE_ATTR_PAUSED)) {
dir = (sprite->attr & SPRITE_ATTR_REVERSE) ? -1 : 1;
for(j=0; j<(int)sprite->speed*minimumVcount; j++) {
loop = (sprite->attr & HUSPR_ATTR_LOOP) ? 0 : 1;
if(!(sprite->attr & HUSPR_ATTR_NOANIM)) {
dir = (sprite->attr & HUSPR_ATTR_REVERSE) ? -1 : 1;
for(j=0; j<(s32)sprite->speed*minimumVcount; j++) {
sprite->time += dir;
SpriteCalcFrame(sprite, bank, &frame, loop);
}
@ -209,7 +208,7 @@ void HuSprPauseSet(BOOL value)
AnimData *HuSprAnimRead(void *data)
{
short i;
s16 i;
AnimBmpData *bmp;
AnimBankData *bank;
AnimPatData *pat;
@ -244,17 +243,17 @@ void HuSprAnimLock(AnimData *anim)
anim->useNum++;
}
short HuSprCreate(AnimData *anim, short prio, short bank)
s16 HuSprCreate(AnimData *anim, s16 prio, s16 bank)
{
SpriteData *sprite;
short i;
for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
HuSprite *sprite;
s16 i;
for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
if(!sprite->data) {
break;
}
}
if(i == SPRITE_MAX) {
return SPRITE_INVALID;
if(i == HUSPR_MAX) {
return HUSPR_NONE;
}
sprite->data = anim;
sprite->speed = 1.0f;
@ -279,34 +278,34 @@ short HuSprCreate(AnimData *anim, short prio, short bank)
return i;
}
short HuSprFuncCreate(void (*func)(SpriteData *sprite), short prio)
s16 HuSprFuncCreate(HuSprFunc func, s16 prio)
{
SpriteData *sprite;
short index = HuSprCreate(NULL, prio, 0);
if(index == SPRITE_INVALID) {
return SPRITE_INVALID;
HuSprite *sprite;
s16 index = HuSprCreate(NULL, prio, 0);
if(index == HUSPR_NONE) {
return HUSPR_NONE;
}
sprite = &HuSprData[index];
sprite->func = func;
sprite->attr |= SPRITE_ATTR_FUNC;
sprite->attr |= HUSPR_ATTR_FUNC;
return index;
}
short HuSprGrpCreate(short capacity)
s16 HuSprGrpCreate(s16 capacity)
{
SpriteGroupData *group;
short i, j;
for(group = HuSprGrpData, i=0; i<SPRITE_GROUP_MAX; i++, group++) {
HuSprGrp *group;
s16 i, j;
for(group = HuSprGrpData, i=0; i<HUSPR_GRP_MAX; i++, group++) {
if(group->capacity == 0) {
break;
}
}
if(i == SPRITE_GROUP_MAX) {
return SPRITE_GROUP_INVALID;
if(i == HUSPR_GRP_MAX) {
return HUSPR_GRP_NONE;
}
group->members = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(short)*capacity);
group->members = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s16)*capacity);
for(j=0; j<capacity; j++) {
group->members[j] = SPRITE_INVALID;
group->members[j] = HUSPR_NONE;
}
group->capacity = capacity;
group->x = group->y = group->z_rot = group->center_x = group->center_y = 0.0f;
@ -314,14 +313,14 @@ short HuSprGrpCreate(short capacity)
return i;
}
short HuSprGrpCopy(short group)
s16 HuSprGrpCopy(s16 group)
{
SpriteGroupData *new_group_ptr;
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short new_group = HuSprGrpCreate(group_ptr->capacity);
short i;
if(new_group == SPRITE_GROUP_INVALID) {
return SPRITE_GROUP_INVALID;
HuSprGrp *new_group_ptr;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 new_group = HuSprGrpCreate(group_ptr->capacity);
s16 i;
if(new_group == HUSPR_GRP_NONE) {
return HUSPR_GRP_NONE;
}
new_group_ptr = &HuSprGrpData[new_group];
new_group_ptr->x = group_ptr->x;
@ -332,9 +331,9 @@ short HuSprGrpCopy(short group)
new_group_ptr->center_x = group_ptr->center_x;
new_group_ptr->center_y = group_ptr->center_y;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
SpriteData *old_sprite = &HuSprData[group_ptr->members[i]];
short new_sprite = HuSprCreate(old_sprite->data, old_sprite->prio, old_sprite->bank);
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprite *old_sprite = &HuSprData[group_ptr->members[i]];
s16 new_sprite = HuSprCreate(old_sprite->data, old_sprite->prio, old_sprite->bank);
HuSprData[new_sprite] = *old_sprite;
HuSprGrpMemberSet(new_group, i, new_sprite);
}
@ -342,32 +341,32 @@ short HuSprGrpCopy(short group)
return new_group;
}
void HuSprGrpMemberSet(short group, short member, short sprite)
void HuSprGrpMemberSet(s16 group, s16 member, s16 sprite)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
SpriteData *sprite_ptr = &HuSprData[sprite];
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] != SPRITE_INVALID) {
HuSprGrp *group_ptr = &HuSprGrpData[group];
HuSprite *sprite_ptr = &HuSprData[sprite];
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] != HUSPR_NONE) {
return;
}
group_ptr->members[member] = sprite;
}
void HuSprGrpMemberKill(short group, short member)
void HuSprGrpMemberKill(s16 group, s16 member)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
HuSprGrp *group_ptr = &HuSprGrpData[group];
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == HUSPR_NONE) {
return;
}
HuSprKill(group_ptr->members[member]);
group_ptr->members[member] = SPRITE_INVALID;
group_ptr->members[member] = HUSPR_NONE;
}
void HuSprGrpKill(short group)
void HuSprGrpKill(s16 group)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprKill(group_ptr->members[i]);
}
}
@ -375,13 +374,13 @@ void HuSprGrpKill(short group)
HuMemDirectFree(group_ptr->members);
}
void HuSprKill(short sprite)
void HuSprKill(s16 sprite)
{
SpriteData *sprite_ptr = &HuSprData[sprite];
HuSprite *sprite_ptr = &HuSprData[sprite];
if(!sprite_ptr->data) {
return;
}
if(!(sprite_ptr->attr & SPRITE_ATTR_FUNC)) {
if(!(sprite_ptr->attr & HUSPR_ATTR_FUNC)) {
HuSprAnimKill(sprite_ptr->data);
if(sprite_ptr->bg) {
HuSprAnimKill(sprite_ptr->bg);
@ -394,7 +393,7 @@ void HuSprKill(short sprite)
void HuSprAnimKill(AnimData *anim)
{
if(--anim->useNum <= 0) {
if(anim->bmpNum & SPRITE_BMP_ALLOC) {
if(anim->bmpNum & ANIM_BMP_ALLOC) {
if(anim->bmp->data) {
HuMemDirectFree(anim->bmp->data);
}
@ -406,11 +405,11 @@ void HuSprAnimKill(AnimData *anim)
}
}
void HuSprAttrSet(short group, short member, int attr)
void HuSprAttrSet(s16 group, s16 member, s32 attr)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
SpriteData *sprite_ptr;
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
HuSprGrp *group_ptr = &HuSprGrpData[group];
HuSprite *sprite_ptr;
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == HUSPR_NONE) {
return;
}
sprite_ptr = &HuSprData[group_ptr->members[member]];
@ -418,11 +417,11 @@ void HuSprAttrSet(short group, short member, int attr)
sprite_ptr->dirty_flag |= SPRITE_DIRTY_ATTR;
}
void HuSprAttrReset(short group, short member, int attr)
void HuSprAttrReset(s16 group, s16 member, s32 attr)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
SpriteData *sprite_ptr;
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
HuSprGrp *group_ptr = &HuSprGrpData[group];
HuSprite *sprite_ptr;
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == HUSPR_NONE) {
return;
}
sprite_ptr = &HuSprData[group_ptr->members[member]];
@ -430,59 +429,59 @@ void HuSprAttrReset(short group, short member, int attr)
sprite_ptr->dirty_flag |= SPRITE_DIRTY_ATTR;
}
void HuSprPosSet(short group, short member, float x, float y)
void HuSprPosSet(s16 group, s16 member, float x, float y)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->x = x;
sprite_ptr->y = y;
sprite_ptr->dirty_flag |= SPRITE_DIRTY_XFORM;
}
void HuSprZRotSet(short group, short member, float z_rot)
void HuSprZRotSet(s16 group, s16 member, float z_rot)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->z_rot = z_rot;
sprite_ptr->dirty_flag |= SPRITE_DIRTY_XFORM;
}
void HuSprScaleSet(short group, short member, float x, float y)
void HuSprScaleSet(s16 group, s16 member, float x, float y)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->scale_x = x;
sprite_ptr->scale_y = y;
sprite_ptr->dirty_flag |= SPRITE_DIRTY_XFORM;
}
void HuSprTPLvlSet(short group, short member, float tp_lvl)
void HuSprTPLvlSet(s16 group, s16 member, float tp_lvl)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->a = tp_lvl*255;
sprite_ptr->dirty_flag |= SPRITE_DIRTY_COLOR;
}
void HuSprColorSet(short group, short member, u8 r, u8 g, u8 b)
void HuSprColorSet(s16 group, s16 member, u8 r, u8 g, u8 b)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->r = r;
sprite_ptr->g = g;
sprite_ptr->b = b;
sprite_ptr->dirty_flag |= SPRITE_DIRTY_COLOR;
}
void HuSprSpeedSet(short group, short member, float speed)
void HuSprSpeedSet(s16 group, s16 member, float speed)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
HuSprGrp *group_ptr = &HuSprGrpData[group];
HuSprData[group_ptr->members[member]].speed = speed;
}
void HuSprBankSet(short group, short member, short bank)
void HuSprBankSet(s16 group, s16 member, s16 bank)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
AnimData *anim = sprite_ptr->data;
AnimBankData *bank_ptr = &anim->bank[sprite_ptr->bank];
AnimFrameData *frame_ptr = &bank_ptr->frame[sprite_ptr->frame];
sprite_ptr->bank = bank;
if(sprite_ptr->attr & SPRITE_ATTR_REVERSE) {
if(sprite_ptr->attr & HUSPR_ATTR_REVERSE) {
sprite_ptr->frame = bank_ptr->timeNum-1;
frame_ptr = &bank_ptr->frame[sprite_ptr->frame];
sprite_ptr->time = frame_ptr->time;
@ -492,10 +491,10 @@ void HuSprBankSet(short group, short member, short bank)
}
}
void HuSprGrpPosSet(short group, float x, float y)
void HuSprGrpPosSet(s16 group, float x, float y)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
group_ptr->x = x;
group_ptr->y = y;
for(i=0; i<group_ptr->capacity; i++) {
@ -505,102 +504,102 @@ void HuSprGrpPosSet(short group, float x, float y)
}
}
void HuSprGrpCenterSet(short group, float x, float y)
void HuSprGrpCenterSet(s16 group, float x, float y)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
group_ptr->center_x = x;
group_ptr->center_y = y;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_XFORM;
}
}
}
void HuSprGrpZRotSet(short group, float z_rot)
void HuSprGrpZRotSet(s16 group, float z_rot)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
group_ptr->z_rot = z_rot;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_XFORM;
}
}
}
void HuSprGrpScaleSet(short group, float x, float y)
void HuSprGrpScaleSet(s16 group, float x, float y)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
group_ptr->scale_x = x;
group_ptr->scale_y = y;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_XFORM;
}
}
}
void HuSprGrpTPLvlSet(short group, float tp_lvl)
void HuSprGrpTPLvlSet(s16 group, float tp_lvl)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprData[group_ptr->members[i]].a = tp_lvl*255;
HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_COLOR;
}
}
}
s32 HuSprGrpDrawNoSet(short group, int draw_no)
s32 HuSprGrpDrawNoSet(s16 group, s32 draw_no)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprData[group_ptr->members[i]].draw_no = draw_no;
}
}
}
void HuSprDrawNoSet(short group, short member, int draw_no)
void HuSprDrawNoSet(s16 group, s16 member, s32 draw_no)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->draw_no = draw_no;
}
void HuSprPriSet(short group, short member, short prio)
void HuSprPriSet(s16 group, s16 member, s16 prio)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->prio = prio;
}
void HuSprGrpScissorSet(short group, short x, short y, short w, short h)
void HuSprGrpScissorSet(s16 group, s16 x, s16 y, s16 w, s16 h)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
HuSprGrp *group_ptr = &HuSprGrpData[group];
s16 i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != SPRITE_INVALID) {
if(group_ptr->members[i] != HUSPR_NONE) {
HuSprScissorSet(group, i, x, y, w, h);
}
}
}
void HuSprScissorSet(short group, short member, short x, short y, short w, short h)
void HuSprScissorSet(s16 group, s16 member, s16 x, s16 y, s16 w, s16 h)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->scissor_x = x;
sprite_ptr->scissor_y = y;
sprite_ptr->scissor_w = w;
sprite_ptr->scissor_h = h;
}
static short bitSizeTbl[11] = { 32, 24, 16, 8, 4, 16, 8, 8, 4, 8, 4 };
static s16 bitSizeTbl[11] = { 32, 24, 16, 8, 4, 16, 8, 8, 4, 8, 4 };
AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
AnimData *HuSprAnimMake(s16 sizeX, s16 sizeY, s16 dataFmt)
{
AnimLayerData *layer;
AnimBmpData *bmp;
@ -627,7 +626,7 @@ AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
anim->useNum = 0;
anim->bankNum = 1;
anim->patNum = 1;
anim->bmpNum = (1|SPRITE_BMP_ALLOC);
anim->bmpNum = (1|ANIM_BMP_ALLOC);
bank->timeNum = 1;
bank->unk = 10;
frame->pat = 0;
@ -663,19 +662,19 @@ AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
return anim;
}
void HuSprBGSet(short group, short member, AnimData *bg, short bg_bank)
void HuSprBGSet(s16 group, s16 member, AnimData *bg, s16 bg_bank)
{
short sprite = HuSprGrpData[group].members[member];
s16 sprite = HuSprGrpData[group].members[member];
HuSprSprBGSet(sprite, bg, bg_bank);
}
void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank)
void HuSprSprBGSet(s16 sprite, AnimData *bg, s16 bg_bank)
{
SpriteData *sprite_ptr = &HuSprData[sprite];
HuSprite *sprite_ptr = &HuSprData[sprite];
sprite_ptr->bg = bg;
sprite_ptr->bg_bank = bg_bank;
sprite_ptr->wrap_t = sprite_ptr->wrap_s = GX_REPEAT;
sprite_ptr->attr &= ~SPRITE_ATTR_BILINEAR;
sprite_ptr->attr &= ~HUSPR_ATTR_LINEAR;
}
void AnimDebug(AnimData *anim)
@ -688,7 +687,7 @@ void AnimDebug(AnimData *anim)
AnimBankData *bank;
AnimBmpData *bmp;
OSReport("patNum %d,bankNum %d,bmpNum %d\n", anim->patNum, anim->bankNum, anim->bmpNum & SPRITE_BMP_NUM_MASK);
OSReport("patNum %d,bankNum %d,bmpNum %d\n", anim->patNum, anim->bankNum, anim->bmpNum & ANIM_BMP_NUM_MASK);
pat = anim->pat;
for(i=0; i<anim->patNum; i++) {
OSReport("PATTERN%d:\n", i);
@ -716,7 +715,7 @@ void AnimDebug(AnimData *anim)
bank++;
}
bmp = anim->bmp;
for(i=0; i<anim->bmpNum & SPRITE_BMP_NUM_MASK; i++) {
for(i=0; i<anim->bmpNum & ANIM_BMP_NUM_MASK; i++) {
OSReport("BMP%d:\n", i);
OSReport("\tpixSize %d,palNum %d,size (%d,%d)\n", bmp->pixSize, bmp->palNum, bmp->sizeX, bmp->sizeY);
bmp++;

40
src/game/sprput.c
View file

@ -40,7 +40,7 @@ void HuSprDispInit(void)
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
}
void HuSprDisp(SpriteData *sprite)
void HuSprDisp(HuSprite *sprite)
{
short i;
AnimData *anim = sprite->data;
@ -48,10 +48,10 @@ void HuSprDisp(SpriteData *sprite)
Vec axis = {0, 0, 1};
Mtx modelview, rot;
short color_sum;
SpriteFunc func;
HuSprFunc func;
GXSetScissor(sprite->scissor_x, sprite->scissor_y, sprite->scissor_w, sprite->scissor_h);
if(sprite->attr & SPRITE_ATTR_FUNC) {
if(sprite->attr & HUSPR_ATTR_FUNC) {
if(sprite->func) {
func = sprite->func;
func(sprite);
@ -80,9 +80,9 @@ void HuSprDisp(SpriteData *sprite)
GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
GXSetNumChans(1);
GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT0, GX_DF_CLAMP, GX_AF_SPOT);
if(sprite->attr & SPRITE_ATTR_ADDITIVE) {
if(sprite->attr & HUSPR_ATTR_ADDCOL) {
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_NOOP);
} else if(sprite->attr & SPRITE_ATTR_INVERT) {
} else if(sprite->attr & HUSPR_ATTR_INVCOL) {
GXSetBlendMode(GX_BM_BLEND, GX_BL_ZERO, GX_BL_INVDSTCLR, GX_LO_NOOP);
} else {
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
@ -123,7 +123,7 @@ void HuSprDisp(SpriteData *sprite)
continue;
}
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & SPRITE_ATTR_BILINEAR) ? GX_LINEAR : GX_NEAR);
HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & HUSPR_ATTR_LINEAR) ? GX_LINEAR : GX_NEAR);
if(layer->alpha != 255 || color_sum != 255*4) {
color.a = (u16)(sprite->a*layer->alpha) >> 8;
GXSetTevColor(GX_TEVSTAGE1, color);
@ -140,14 +140,14 @@ void HuSprDisp(SpriteData *sprite)
pos[2][1] = layer->vtx[5]-pat->centerY;
pos[3][0] = layer->vtx[6]-pat->centerX;
pos[3][1] = layer->vtx[7]-pat->centerY;
if(layer->flip & SPRITE_LAYER_FLIPX) {
if(layer->flip & ANIM_LAYER_FLIPX) {
texcoord_x2 = layer->startX/(float)bmp->sizeX;
texcoord_x1 = (layer->startX+layer->sizeX)/(float)bmp->sizeX;
} else {
texcoord_x1 = layer->startX/(float)bmp->sizeX;
texcoord_x2 = (layer->startX+layer->sizeX)/(float)bmp->sizeX;
}
if(layer->flip & SPRITE_LAYER_FLIPY) {
if(layer->flip & ANIM_LAYER_FLIPY) {
texcoord_y2 = layer->startY/(float)bmp->sizeY;
texcoord_y1 = (layer->startY+layer->sizeY)/(float)bmp->sizeY;
} else {
@ -188,49 +188,49 @@ void HuSprTexLoad(AnimData *anim, short bmp, short slot, GXTexWrapMode wrap_s, G
AnimBmpData *bmp_ptr = &anim->bmp[bmp];
short sizeX = bmp_ptr->sizeX;
short sizeY = bmp_ptr->sizeY;
switch(bmp_ptr->dataFmt & SPRITE_BMP_FMTMASK) {
case SPRITE_BMP_RGBA8:
switch(bmp_ptr->dataFmt & ANIM_BMP_FMTMASK) {
case ANIM_BMP_RGBA8:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_RGBA8, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_RGB5A3:
case SPRITE_BMP_RGB5A3_DUPE:
case ANIM_BMP_RGB5A3:
case ANIM_BMP_RGB5A3_DUPE:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_RGB5A3, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_C8:
case ANIM_BMP_C8:
GXInitTlutObj(&tlut_obj, bmp_ptr->palData, GX_TL_RGB5A3, bmp_ptr->palNum);
GXLoadTlut(&tlut_obj, slot);
GXInitTexObjCI(&tex_obj,bmp_ptr->data, sizeX, sizeY, GX_TF_C8, wrap_s, wrap_t, GX_FALSE, slot);
break;
case SPRITE_BMP_C4:
case ANIM_BMP_C4:
GXInitTlutObj(&tlut_obj, bmp_ptr->palData, GX_TL_RGB5A3, bmp_ptr->palNum);
GXLoadTlut(&tlut_obj, slot);
GXInitTexObjCI(&tex_obj,bmp_ptr->data, sizeX, sizeY, GX_TF_C4, wrap_s, wrap_t, GX_FALSE, slot);
break;
case SPRITE_BMP_IA8:
case ANIM_BMP_IA8:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_IA8, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_IA4:
case ANIM_BMP_IA4:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_IA4, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_I8:
case ANIM_BMP_I8:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_I8, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_I4:
case ANIM_BMP_I4:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_I4, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_A8:
case ANIM_BMP_A8:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_CTF_A8, wrap_s, wrap_t, GX_FALSE);
break;
case SPRITE_BMP_CMPR:
case ANIM_BMP_CMPR:
GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_CMPR, wrap_s, wrap_t, GX_FALSE);
break;

4
src/game/thpmain.c
View file

@ -10,7 +10,7 @@
static void THPTestProc(void);
static void THPViewFunc(ModelData *arg0, Mtx arg1);
static void THPViewSprFunc(SpriteData *arg0);
static void THPViewSprFunc(HuSprite *arg0);
static void THPDecodeFunc(void *param);
static char THPFileName[64];
@ -210,7 +210,7 @@ static void THPViewFunc(ModelData *arg0, Mtx arg1) {
}
}
static void THPViewSprFunc(SpriteData *arg0) {
static void THPViewSprFunc(HuSprite *arg0) {
Vec spC = { 0.0f, 0.0f, 1.0f };
GXColor sp8;
s32 temp_r30;

24
src/game/window.c
View file

@ -30,7 +30,7 @@ typedef struct {
/* 0x04 */ u32 player[4];
} keyBufData; // Size 0x14
static void MesDispFunc(SpriteData *sprite);
static void MesDispFunc(HuSprite *sprite);
static u8 winBGMake(AnimData *bg, AnimData *frame);
static void HuWinProc(void);
static void HuWinDrawMes(s16 window);
@ -252,7 +252,7 @@ void HuWinInit(s32 mess_data_no) {
s16 HuWinCreate(float x, float y, s16 w, s16 h, s16 frame) {
AnimData *bg_anim;
WindowData *window;
SpriteData *sprite_ptr;
HuSprite *sprite_ptr;
s16 group;
s16 sprite;
s16 window_id;
@ -407,9 +407,9 @@ void HuWinAllKill(void) {
HuDataDirClose(DATADIR_WIN);
}
static void MesDispFunc(SpriteData *sprite) {
static void MesDispFunc(HuSprite *sprite) {
WindowData *window = &winData[sprite->work[0]];
SpriteGroupData *group;
HuSprGrp *group;
float uv_maxx;
float uv_maxy;
float uv_minx;
@ -608,7 +608,7 @@ static inline void charEntry(s16 window, s16 x, s16 y, s16 char_idx, s16 color)
static void HuWinDrawMes(s16 window) {
WindowData *window_ptr = &winData[window];
SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
HuSprGrp *group = &HuSprGrpData[window_ptr->group];
s16 c;
s16 i;
s16 char_w;
@ -888,7 +888,7 @@ static void HuWinKeyWait(s16 window) {
}
static s16 HuWinSpcFontEntry(WindowData *window, s16 entry, s16 x, s16 y) {
SpriteGroupData *group = &HuSprGrpData[window->group];
HuSprGrp *group = &HuSprGrpData[window->group];
s16 sprite;
s16 i;
AnimData *anim;
@ -906,7 +906,7 @@ static s16 HuWinSpcFontEntry(WindowData *window, s16 entry, s16 x, s16 y) {
}
static void HuWinSpcFontPosSet(WindowData *window, s16 index, s16 x, s16 y) {
SpriteGroupData *group = &HuSprGrpData[window->group];
HuSprGrp *group = &HuSprGrpData[window->group];
HuSprPosSet(window->group, index, x - window->w / 2, y - window->h / 2);
}
@ -1372,7 +1372,7 @@ void HuWinAnimSet(s16 window, AnimData *anim, s16 bank, float x, float y) {
s16 HuWinSprSet(s16 window, s16 sprite, float x, float y) {
WindowData *window_ptr = &winData[window];
SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
HuSprGrp *group = &HuSprGrpData[window_ptr->group];
s16 i;
for (i=2; i<=9; i++) {
@ -1388,14 +1388,14 @@ s16 HuWinSprSet(s16 window, s16 sprite, float x, float y) {
void HuWinSprPosSet(s16 window, s16 index, float x, float y) {
WindowData *window_ptr = &winData[window];
SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
HuSprGrp *group = &HuSprGrpData[window_ptr->group];
HuSprPosSet(window_ptr->group, index, x - group->center_x, y - group->center_y);
}
void HuWinSprPriSet(s16 window, s16 index, s16 prio) {
WindowData *window_ptr = &winData[window];
SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
HuSprGrp *group = &HuSprGrpData[window_ptr->group];
HuSprPriSet(window_ptr->group, index, prio);
}
@ -1419,7 +1419,7 @@ void HuWinDispOff(s16 window) {
for(i=0; i<30; i++) {
if (window_ptr->sprite_id[i] != -1) {
HuSprAttrSet(window_ptr->group, i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(window_ptr->group, i, HUSPR_ATTR_DISPOFF);
}
}
window_ptr->attr |= 8;
@ -1431,7 +1431,7 @@ void HuWinDispOn(s16 window) {
for (i=0; i<30; i++) {
if (window_ptr->sprite_id[i] != -1) {
HuSprAttrReset(window_ptr->group, i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(window_ptr->group, i, HUSPR_ATTR_DISPOFF);
}
}
window_ptr->attr = window_ptr->attr & ~8;