Finish Decompiling sprman.c

include/common_structs.h

@@ -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;
+    u8 r;
-    char g;
+    u8 g;
-    char b;
+    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;
+    unsigned short group;
-    u16 sprite;
+    unsigned short sprite;
-    u16 prio;
+    unsigned short prio;
-    u16 next;
+    unsigned short next;
 } SpriteOrderData;
 
 #endif

include/functions.h

@@ -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);

include/variables.h

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

src/game/sprman.c

@@ -6,32 +6,26 @@ SpriteGroupData HuSprGrpData[256];
 static SpriteOrderData HuSprOrder[384*2];
 
 
-static s16 HuSprOrderNum;
+static short HuSprOrderNum;
-static s16 HuSprOrderNo;
+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);
+static void HuSprOrderEntry(short group, short sprite);
-
-extern u32 minimumVcount;
 
 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;
+    short prio = HuSprData[sprite].prio;
-    s16 prev, next;
+    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;
+    short i;
-    s16 j;
+    short j;
-    s16 wrap;
+    short wrap;
-    s16 dir;
+    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) {
+                        SpriteCalcFrame(sprite, bank, &frame, wrap);
-                            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;
-                        }
                     }
                     sprite->time += (sprite->speed*(float)minimumVcount)-j;
-                    if(sprite->time >= frame->time) {
+                    SpriteCalcFrame(sprite, bank, &frame, wrap);
-                        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;
-                    }
                 }
                 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++;
+    }
+}