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

Finish Decompiling sprman.c

Browse source
This commit is contained in:
gamemasterplc 2023-12-02 21:26:15 -06:00
parent fbe16f2995
commit a931f0297d
4 changed files with 583 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

27
include/common_structs.h
View file

@ -170,6 +170,7 @@ typedef struct anim_time_data {
typedef struct anim_bank_data {
s16 timeNum;
s16 unk;
AnimFrameData *frame;
} AnimBankData;
@ -217,9 +218,9 @@ typedef struct anim_data {
} AnimData;
typedef struct sprite_data {
char r;
char g;
char b;
u8 r;
u8 g;
u8 b;
char draw_no;
short frame;
short bank;
@ -229,11 +230,11 @@ typedef struct sprite_data {
float time;
float x;
float y;
float rot;
float z_rot;
float scale_x;
float scale_y;
float speed;
float alpha;
float a;
GXTexWrapMode wrap_s;
GXTexWrapMode wrap_t;
short tex_scale_x;
@ -247,7 +248,7 @@ typedef struct sprite_data {
AnimFrameData *frame_data;
short work[4];
AnimData *bg;
short bg_bank;
unsigned short bg_bank;
short scissor_x;
short scissor_y;
short scissor_w;
@ -255,23 +256,23 @@ typedef struct sprite_data {
} SpriteData;
typedef struct sprite_group_data {
short num_members;
short capacity;
float x;
float y;
float rot;
float z_rot;
float scale_x;
float scale_y;
float center_x;
float center_y;
s16 *members;
short *members;
Mtx mtx;
} SpriteGroupData;
typedef struct sprite_order_data {
u16 group;
u16 sprite;
u16 prio;
u16 next;
unsigned short group;
unsigned short sprite;
unsigned short prio;
unsigned short next;
} SpriteOrderData;
#endif

40
include/functions.h
View file

@ -159,7 +159,47 @@ void espKill(s16);
void espDispOn(s16);
void espPosSet(s16, f32, f32);
void HuSprInit(void);
void HuSprClose(void);
void HuSprExec(short draw_no);
void HuSprBegin(void);
SpriteData *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(void (*func)(SpriteData *sprite), 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);
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);
void 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 AnimDebug(AnimData *anim);
void HuWinAllKill(void);
void HuWinMesSet(s16, s32);

2
include/variables.h
View file

@ -46,4 +46,6 @@ extern OverlayID omprevovl;
extern PlayerState GWPlayer[4];
extern SystemState GWSystem;
extern u32 minimumVcount;
#endif

601
src/game/sprman.c
View file

@ -6,32 +6,26 @@ SpriteGroupData HuSprGrpData[256];
static SpriteOrderData HuSprOrder[384*2];
static s16 HuSprOrderNum;
static s16 HuSprOrderNo;
static short HuSprOrderNum;
static short HuSprOrderNo;
static BOOL HuSprPauseF;
void HuSprGrpKill(s16 i);
void HuSprKill(s16 i);
void HuSprDisp(SpriteData *sprite);
SpriteData *HuSprCall();
static void HuSprOrderEntry(s16 group, s16 sprite);
extern u32 minimumVcount;
static void HuSprOrderEntry(short group, short sprite);
void mtxTransCat(Mtx matrix, float x, float y, int z); //Last argument should be a float
void HuSprInit(void)
{
s16 i;
short i;
SpriteData *sprite;
SpriteGroupData *group;
for(sprite = &HuSprData[1], i=1; i<384; i++, sprite++) {
sprite->data = NULL;
}
for(group = HuSprGrpData, i=0; i<256; i++, group++) {
group->num_members = 0;
group->capacity = 0;
}
sprite = &HuSprData[0];
sprite->prio = 0;
@ -41,12 +35,12 @@ void HuSprInit(void)
void HuSprClose(void)
{
s16 i;
short i;
SpriteGroupData *group;
SpriteData *sprite;
for(group = HuSprGrpData, i=0; i<256; i++, group++) {
if(group->num_members != 0) {
if(group->capacity != 0) {
HuSprGrpKill(i);
}
}
@ -58,7 +52,7 @@ void HuSprClose(void)
HuSprPauseF = FALSE;
}
void HuSprExec(s16 draw_no)
void HuSprExec(short draw_no)
{
SpriteData *sprite;
while(sprite = HuSprCall()) {
@ -71,7 +65,7 @@ void HuSprExec(s16 draw_no)
void HuSprBegin(void)
{
Mtx temp, rot;
s16 i, j;
short i, j;
Vec axis = {0, 0, 1};
SpriteGroupData *group;
group = HuSprGrpData;
@ -79,14 +73,14 @@ void HuSprBegin(void)
HuSprOrder[0].next = 0;
HuSprOrder[0].prio = -1;
for(i=0; i<256; i++, group++) {
if(group->num_members != 0) {
if(group->capacity != 0) {
MTXTrans(temp, group->center_x*group->scale_x, group->center_y*group->scale_y, 0.0f);
MTXRotAxisDeg(rot, &axis, group->rot);
MTXRotAxisDeg(rot, &axis, group->z_rot);
MTXConcat(rot, temp, group->mtx);
MTXScale(temp, group->scale_x, group->scale_y, 1.0f);
MTXConcat(group->mtx, temp, group->mtx);
mtxTransCat(group->mtx, group->x, group->y, 0);
for(j=0; j<group->num_members; j++) {
for(j=0; j<group->capacity; j++) {
if(group->members[j] != -1) {
HuSprOrderEntry(i, group->members[j]);
}
@ -96,11 +90,11 @@ void HuSprBegin(void)
HuSprOrderNo = 0;
}
static void HuSprOrderEntry(s16 group, s16 sprite)
static void HuSprOrderEntry(short group, short sprite)
{
SpriteOrderData *order = &HuSprOrder[HuSprOrderNum];
s16 prio = HuSprData[sprite].prio;
s16 prev, next;
short prio = HuSprData[sprite].prio;
short prev, next;
if(HuSprOrderNum >= 384*2) {
OSReport("Order Max Over!\n");
return;
@ -137,16 +131,43 @@ SpriteData *HuSprCall(void)
}
}
static inline void SpriteCalcFrame(SpriteData *sprite, AnimBankData *bank, AnimFrameData **frame, short wrap)
{
if(sprite->time >= (*frame)->time) {
sprite->frame++;
sprite->time -= (*frame)->time;
if(sprite->frame >= bank->timeNum || (*frame)[1].time == -1) {
if(wrap) {
sprite->frame = 0;
} else {
sprite->frame = bank->timeNum-1;
}
}
*frame = &bank->frame[sprite->frame];
} else if(sprite->time < 0) {
sprite->frame--;
if(sprite->frame < 0) {
if(wrap) {
sprite->frame = bank->timeNum-1;
} else {
sprite->frame = 0;
}
}
*frame = &bank->frame[sprite->frame];
sprite->time += (*frame)->time;
}
}
void HuSprFinish(void)
{
AnimData *anim;
AnimBankData *bank;
AnimFrameData *frame;
SpriteData *sprite;
s16 i;
s16 j;
s16 wrap;
s16 dir;
short i;
short j;
short wrap;
short dir;
for(sprite = &HuSprData[1], i=1; i<384; i++, sprite++) {
@ -160,54 +181,10 @@ void HuSprFinish(void)
dir = (sprite->attr & 0x40) ? -1 : 1;
for(j=0; j<(int)sprite->speed*minimumVcount; j++) {
sprite->time += dir;
if(sprite->time >= frame->time) {
sprite->frame++;
sprite->time -= frame->time;
if(sprite->frame >= bank->timeNum || frame[1].time == -1) {
if(wrap) {
sprite->frame = 0;
} else {
sprite->frame = bank->timeNum-1;
}
}
frame = &bank->frame[sprite->frame];
} else if(sprite->time < 0) {
sprite->frame--;
if(sprite->frame < 0) {
if(wrap) {
sprite->frame = bank->timeNum-1;
} else {
sprite->frame = 0;
}
}
frame = &bank->frame[sprite->frame];
sprite->time += frame->time;
}
SpriteCalcFrame(sprite, bank, &frame, wrap);
}
sprite->time += (sprite->speed*(float)minimumVcount)-j;
if(sprite->time >= frame->time) {
sprite->frame++;
sprite->time -= frame->time;
if(sprite->frame >= bank->timeNum || frame[1].time == -1) {
if(wrap) {
sprite->frame = 0;
} else {
sprite->frame = bank->timeNum-1;
}
}
frame = &bank->frame[sprite->frame];
} else if(sprite->time < 0) {
sprite->frame--;
if(sprite->frame < 0) {
if(wrap) {
sprite->frame = bank->timeNum-1;
} else {
sprite->frame = 0;
}
}
frame = &bank->frame[sprite->frame];
sprite->time += frame->time;
}
SpriteCalcFrame(sprite, bank, &frame, wrap);
}
sprite->dirty_flag = 0;
}
@ -222,12 +199,11 @@ void HuSprPauseSet(BOOL value)
AnimData *HuSprAnimRead(void *data)
{
s16 i;
short i;
AnimBmpData *bmp;
AnimBankData *bank;
AnimPatData *pat;
AnimData *anim = (AnimData *)data;
if((u32)anim->bank & 0xFFFF0000) {
anim->useNum++;
@ -258,4 +234,481 @@ void HuSprAnimLock(AnimData *anim)
anim->useNum++;
}
static s16 bitSizeTbl[11] = { 32, 24, 16, 8, 4, 10, 8, 8, 4, 8, 4 };
short HuSprCreate(AnimData *anim, short prio, short bank)
{
SpriteData *sprite;
short i;
for(sprite = &HuSprData[1], i=1; i<384; i++, sprite++) {
if(!sprite->data) {
break;
}
}
if(i == 384) {
return -1;
}
sprite->data = anim;
sprite->speed = 1.0f;
sprite->frame = 0;
sprite->bank = bank;
sprite->time = 0.0f;
sprite->attr = 0;
sprite->draw_no = 0;
sprite->r = sprite->g = sprite->b = sprite->a = 255;
sprite->x = sprite->y = sprite->z_rot = 0.0f;
sprite->prio = prio;
sprite->scale_x = sprite->scale_y = 1.0f;
sprite->wrap_s = sprite->wrap_t = GX_CLAMP;
sprite->tex_scale_x = sprite->tex_scale_y = 1;
sprite->bg = NULL;
sprite->scissor_x = sprite->scissor_y = 0;
sprite->scissor_w = 640;
sprite->scissor_h = 480;
if(anim) {
HuSprAnimLock(anim);
}
return i;
}
short HuSprFuncCreate(void (*func)(SpriteData *sprite), short prio)
{
SpriteData *sprite;
short index = HuSprCreate(NULL, prio, 0);
if(index == -1) {
return -1;
}
sprite = &HuSprData[index];
sprite->func = func;
sprite->attr |= 0x10;
return index;
}
short HuSprGrpCreate(short capacity)
{
SpriteGroupData *group;
short i, j;
for(group = HuSprGrpData, i=0; i<256; i++, group++) {
if(group->capacity == 0) {
break;
}
}
if(i == 256) {
return -1;
}
group->members = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(short)*capacity);
for(j=0; j<capacity; j++) {
group->members[j] = -1;
}
group->capacity = capacity;
group->x = group->y = group->z_rot = group->center_x = group->center_y = 0.0f;
group->scale_x = group->scale_y = 1.0f;
return i;
}
short HuSprGrpCopy(short group)
{
SpriteGroupData *new_group_ptr;
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short new_group = HuSprGrpCreate(group_ptr->capacity);
short i;
if(new_group == -1) {
return -1;
}
new_group_ptr = &HuSprGrpData[new_group];
new_group_ptr->x = group_ptr->x;
new_group_ptr->y = group_ptr->y;
new_group_ptr->z_rot = group_ptr->z_rot;
new_group_ptr->scale_x = group_ptr->scale_x;
new_group_ptr->scale_y = group_ptr->scale_y;
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] != -1) {
SpriteData *old_sprite = &HuSprData[group_ptr->members[i]];
short new_sprite = HuSprCreate(old_sprite->data, old_sprite->prio, old_sprite->bank);
HuSprData[new_sprite] = *old_sprite;
HuSprGrpMemberSet(new_group, i, new_sprite);
}
}
return new_group;
}
void HuSprGrpMemberSet(short group, short member, short sprite)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
SpriteData *sprite_ptr = &HuSprData[sprite];
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] != -1) {
return;
}
group_ptr->members[member] = sprite;
}
void HuSprGrpMemberKill(short group, short member)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == -1) {
return;
}
HuSprKill(group_ptr->members[member]);
group_ptr->members[member] = -1;
}
void HuSprGrpKill(short group)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprKill(group_ptr->members[i]);
}
}
group_ptr->capacity = 0;
HuMemDirectFree(group_ptr->members);
}
void HuSprKill(short sprite)
{
SpriteData *sprite_ptr = &HuSprData[sprite];
if(!sprite_ptr->data) {
return;
}
if(!(sprite_ptr->attr & 0x10)) {
HuSprAnimKill(sprite_ptr->data);
if(sprite_ptr->bg) {
HuSprAnimKill(sprite_ptr->bg);
sprite_ptr->bg = NULL;
}
}
sprite_ptr->data = NULL;
}
void HuSprAnimKill(AnimData *anim)
{
if(--anim->useNum <= 0) {
if(anim->bmpNum & 0x8000) {
if(anim->bmp->data) {
HuMemDirectFree(anim->bmp->data);
}
if(anim->bmp->palData) {
HuMemDirectFree(anim->bmp->palData);
}
}
HuMemDirectFree(anim);
}
}
void HuSprAttrSet(short group, short member, int attr)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
SpriteData *sprite_ptr;
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == -1) {
return;
}
sprite_ptr = &HuSprData[group_ptr->members[member]];
sprite_ptr->attr |= attr;
sprite_ptr->dirty_flag |= 0x1;
}
void HuSprAttrReset(short group, short member, int attr)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
SpriteData *sprite_ptr;
if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == -1) {
return;
}
sprite_ptr = &HuSprData[group_ptr->members[member]];
sprite_ptr->attr &= ~attr;
sprite_ptr->dirty_flag |= 0x1;
}
void HuSprPosSet(short group, short member, float x, float y)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->x = x;
sprite_ptr->y = y;
sprite_ptr->dirty_flag |= 0x2;
}
void HuSprZRotSet(short group, short member, float z_rot)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->z_rot = z_rot;
sprite_ptr->dirty_flag |= 0x2;
}
void HuSprScaleSet(short group, short member, float x, float y)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->scale_x = x;
sprite_ptr->scale_y = y;
sprite_ptr->dirty_flag |= 0x2;
}
void HuSprTPLvlSet(short group, short member, float tp_lvl)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->a = tp_lvl*255;
sprite_ptr->dirty_flag |= 0x4;
}
void HuSprColorSet(short group, short member, u8 r, u8 g, u8 b)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->r = r;
sprite_ptr->g = g;
sprite_ptr->b = b;
sprite_ptr->dirty_flag |= 0x4;
}
void HuSprSpeedSet(short group, short member, float speed)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
HuSprData[group_ptr->members[member]].speed = speed;
}
void HuSprBankSet(short group, short member, short bank)
{
SpriteData *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 & 0x40) {
sprite_ptr->frame = bank_ptr->timeNum-1;
frame_ptr = &bank_ptr->frame[sprite_ptr->frame];
sprite_ptr->time = frame_ptr->time;
} else {
sprite_ptr->time = 0;
sprite_ptr->frame = 0;
}
}
void HuSprGrpPosSet(short group, float x, float y)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
group_ptr->x = x;
group_ptr->y = y;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprData[group_ptr->members[i]].dirty_flag |= 0x2;
}
}
}
void HuSprGrpCenterSet(short group, float x, float y)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
group_ptr->center_x = x;
group_ptr->center_y = y;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprData[group_ptr->members[i]].dirty_flag |= 0x2;
}
}
}
void HuSprGrpZRotSet(short group, float z_rot)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
group_ptr->z_rot = z_rot;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprData[group_ptr->members[i]].dirty_flag |= 0x2;
}
}
}
void HuSprGrpScaleSet(short group, float x, float y)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
group_ptr->scale_x = x;
group_ptr->scale_y = y;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprData[group_ptr->members[i]].dirty_flag |= 0x2;
}
}
}
void HuSprGrpTPLvlSet(short group, float tp_lvl)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprData[group_ptr->members[i]].a = tp_lvl*255;
HuSprData[group_ptr->members[i]].dirty_flag |= 0x4;
}
}
}
void HuSprGrpDrawNoSet(short group, int draw_no)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprData[group_ptr->members[i]].draw_no = draw_no;
}
}
}
void HuSprDrawNoSet(short group, short member, int draw_no)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->draw_no = draw_no;
}
void HuSprPriSet(short group, short member, short prio)
{
SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
sprite_ptr->prio = prio;
}
void HuSprGrpScissorSet(short group, short x, short y, short w, short h)
{
SpriteGroupData *group_ptr = &HuSprGrpData[group];
short i;
for(i=0; i<group_ptr->capacity; i++) {
if(group_ptr->members[i] != -1) {
HuSprScissorSet(group, i, x, y, w, h);
}
}
}
void HuSprScissorSet(short group, short member, short x, short y, short w, short h)
{
SpriteData *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 };
AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
{
AnimLayerData *layer;
AnimBmpData *bmp;
AnimData *anim;
AnimPatData *pat;
AnimFrameData *frame;
void *temp;
AnimBankData *bank;
AnimData *new_anim;
anim = new_anim = HuMemDirectMalloc(HEAP_DATA, sizeof(AnimData)+sizeof(AnimBankData)+sizeof(AnimFrameData)
+sizeof(AnimPatData)+sizeof(AnimLayerData)+sizeof(AnimBmpData));
bank = temp = &new_anim[1];
anim->bank = bank;
frame = temp = ((char *)temp+sizeof(AnimBankData));
bank->frame = frame;
pat = temp = ((char *)temp+sizeof(AnimFrameData));
anim->pat = pat;
layer = temp = ((char *)temp+sizeof(AnimPatData));
pat->layer = layer;
bmp = temp = ((char *)temp+sizeof(AnimLayerData));
anim->bmp = bmp;
anim->useNum = 0;
anim->bankNum = 1;
anim->patNum = 1;
anim->bmpNum = (1|0x8000);
bank->timeNum = 1;
bank->unk = 10;
frame->pat = 0;
frame->time = 10;
frame->shiftX = frame->shiftY = frame->flip = 0;
pat->layerNum = 1;
pat->centerX = sizeX/2;
pat->centerY = sizeY/2;
pat->sizeX = sizeX;
pat->sizeY = sizeY;
layer->alpha = 255;
layer->flip = 0;
layer->bmpNo = 0;
layer->startX = layer->startY = 0;
layer->sizeX = sizeX;
layer->sizeY = sizeY;
layer->shiftX = layer->shiftY = 0;
layer->vtx[0] = layer->vtx[1] = 0;
layer->vtx[2] = sizeX;
layer->vtx[3] = 0;
layer->vtx[4] = sizeX;
layer->vtx[5] = sizeY;
layer->vtx[6] = 0;
layer->vtx[7] = sizeY;
bmp->pixSize = bitSizeTbl[dataFmt];
bmp->dataFmt = dataFmt;
bmp->palNum = 0;
bmp->sizeX = sizeX;
bmp->sizeY = sizeY;
bmp->dataSize = sizeX*sizeY*bitSizeTbl[dataFmt]/8;
bmp->palData = NULL;
bmp->data = NULL;
return anim;
}
void HuSprBGSet(short group, short member, AnimData *bg, short bg_bank)
{
short sprite = HuSprGrpData[group].members[member];
HuSprSprBGSet(sprite, bg, bg_bank);
}
void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank)
{
SpriteData *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 &= ~0x8;
}
void AnimDebug(AnimData *anim)
{
AnimPatData *pat;
AnimLayerData *layer;
s16 i;
s16 j;
AnimFrameData *frame;
AnimBankData *bank;
AnimBmpData *bmp;
OSReport("patNum %d,bankNum %d,bmpNum %d\n", anim->patNum, anim->bankNum, anim->bmpNum & 0x7FFF);
pat = anim->pat;
for(i=0; i<anim->patNum; i++) {
OSReport("PATTERN%d:\n", i);
OSReport("\tlayerNum %d,center (%d,%d),size (%d,%d)\n", pat->layerNum, pat->centerX, pat->centerX, pat->sizeX, pat->sizeY);
layer = pat->layer;
for(j=0; j<pat->layerNum; j++) {
OSReport("\t\tfileNo %d,flip %x\n", layer->bmpNo, layer->flip);
OSReport("\t\tstart (%d,%d),size (%d,%d),shift (%d,%d)\n", layer->startX, layer->startY, layer->sizeX, layer->sizeY, layer->shiftX, layer->shiftY);
if(j != pat->layerNum-1) {
OSReport("\n");
}
layer++;
}
pat++;
}
bank = anim->bank;
for(i=0; i<anim->bankNum; i++) {
OSReport("BANK%d:\n", i);
OSReport("\ttimeNum %d\n", bank->timeNum);
frame = bank->frame;
for(j=0; j<bank->timeNum; j++) {
OSReport("\t\tpat %d,time %d,shift(%d,%d),flip %x\n", frame->pat, frame->time, frame->shiftX, frame->shiftY, frame->flip);
frame++;
}
bank++;
}
bmp = anim->bmp;
for(i=0; i<anim->bmpNum & 0x7FFF; i++) {
OSReport("BMP%d:\n", i);
OSReport("\tpixSize %d,palNum %d,size (%d,%d)\n", bmp->pixSize, bmp->palNum, bmp->sizeX, bmp->sizeY);
bmp++;
}
}