Start Splitting Out Headers

include/game/data.h

@@ -0,0 +1,72 @@
+#ifndef _GAME_DATA_H
+#define _GAME_DATA_H
+
+#include "game/dvd.h"
+
+#define DATA_DECODE_NONE 0
+#define DATA_DECODE_LZ 1
+#define DATA_DECODE_SLIDE 2
+#define DATA_DECODE_FSLIDE_ALT 3
+#define DATA_DECODE_FSLIDE 4
+#define DATA_DECODE_RLE 5
+
+#define MAKE_DATA_NUM(dir, file) (((dir) << 16)+(file))
+#define MAKE_DIR_NUM(dir) ((dir) << 16)
+
+#define DATA_NUM_LISTEND -1
+
+#include "dolphin/types.h"
+
+#define DATADIR_DEFINE(name, path) name,
+
+typedef enum {
+    #include "datadir_table.h"
+    DATADIR_COUNT
+} DataDirID;
+
+#undef DATADIR_DEFINE
+
+typedef struct data_read_stat {
+    s32 dir_id;
+    void *dir;
+    void *file;
+    u32 raw_len;
+    u32 comp_type;
+    BOOL used;
+    s32 num;
+    u32 status;
+    DVDFileInfo file_info;
+} DataReadStat;
+
+void HuDataInit(void);
+int HuDataReadChk(s32 data_num);
+DataReadStat *HuDataGetStatus(void *dir_ptr);
+void *HuDataGetDirPtr(s32 data_num);
+DataReadStat *HuDataDirRead(s32 data_num);
+DataReadStat *HuDataDirReadNum(s32 data_num, s32 num);
+DataReadStat *HuDataDirSet(void *dir_ptr, s32 data_num);
+void HuDataDirReadAsyncCallBack(s32 result, DVDFileInfo* fileInfo);
+s32 HuDataDirReadAsync(s32 data_num);
+s32 HuDataDirReadNumAsync(s32 data_num, s32 num);
+BOOL HuDataGetAsyncStat(s32 status);
+void *HuDataRead(s32 data_num);
+void *HuDataReadNum(s32 data_num, s32 num);
+void *HuDataSelHeapRead(s32 data_num, HeapID heap);
+void *HuDataSelHeapReadNum(s32 data_num, s32 num, HeapID heap);
+void **HuDataReadMulti(s32 *data_ids);
+s32 HuDataGetSize(s32 data_num);
+void HuDataClose(void *ptr);
+void HuDataCloseMulti(void **ptrs);
+void HuDataDirClose(s32 data_id);
+void HuDataDirCloseNum(s32 num);
+void *HuDataReadNumHeapShortForce(s32 data_id, s32 num, HeapID heap);
+
+void HuDecodeData(void *src, void *dst, u32 size, int decode_type);
+
+void *HuARDirCheck(s32 dir);
+void HuAR_ARAMtoMRAM(void *dst);
+void HuAR_ARAMtoMRAMNum(void *dst, s32 num);
+BOOL HuARDMACheck();
+
+
+#endif

include/game/dvd.h

@@ -0,0 +1,24 @@
+#ifndef _GAME_DVD_H
+#define _GAME_DVD_H
+
+#include "dolphin.h"
+#include "game/memory.h"
+
+typedef struct data_read_stat DataReadStat;
+
+typedef struct file_list_entry {
+    char *name;
+    s32 file_id;
+} FileListEntry;
+
+void *HuDvdDataRead(char *path);
+void **HuDvdDataReadMulti(char **paths);
+void *HuDvdDataReadDirect(char *path, HeapID heap);
+void *HuDvdDataFastRead(s32 entrynum);
+void *HuDvdDataFastReadNum(s32 entrynum, s32 num);
+void *HuDvdDataFastReadAsync(s32 entrynum, DataReadStat *stat);
+void HuDvdDataClose(void *ptr);
+void HuDvdErrorWatch();
+
+
+#endif

include/game/init.h

@@ -0,0 +1,20 @@
+#ifndef _GAME_INIT_H
+#define _GAME_INIT_H
+
+#include "dolphin.h"
+
+extern GXRenderModeObj *RenderMode;
+extern OSHeapHandle currentHeapHandle;
+
+extern void *DemoFrameBuffer1;
+extern void *DemoFrameBuffer2;
+extern void *DemoCurrentBuffer;
+extern u32 minimumVcount;
+extern float minimumVcountf;
+extern u32 worstVcount;
+
+void HuSysInit(GXRenderModeObj *mode);
+void HuSysBeforeRender();
+void HuSysDoneRender(s32 retrace_count);
+
+#endif

include/game/memory.h

@@ -0,0 +1,40 @@
+#ifndef _GAME_MEMORY_H
+#define _GAME_MEMORY_H
+
+#include "dolphin/types.h"
+
+#define MEMORY_DEFAULT_NUM 0x10000000
+
+typedef enum {
+    HEAP_SYSTEM,
+    HEAP_MUSIC,
+    HEAP_DATA,
+    HEAP_DVD,
+    HEAP_MISC,
+    HEAP_MAX
+} HeapID;
+
+void HuMemInitAll(void);
+void *HuMemInit(void *ptr, s32 size);
+void HuMemDCFlushAll();
+void HuMemDCFlush(HeapID heap);
+void *HuMemDirectMalloc(HeapID heap, s32 size);
+void *HuMemDirectMallocNum(HeapID heap, s32 size, u32 num);
+void HuMemDirectFree(void *ptr);
+void HuMemDirectFreeNum(HeapID heap, u32 num);
+s32 HuMemUsedMallocSizeGet(HeapID heap);
+s32 HuMemUsedMallocBlockGet(HeapID heap);
+u32 HuMemHeapSizeGet(HeapID heap);
+void *HuMemHeapPtrGet(HeapID heap);
+
+void *HuMemHeapInit(void *ptr, s32 size);
+void *HuMemMemoryAlloc(void *heap_ptr, s32 size, u32 retaddr);
+void *HuMemMemoryAllocNum(void *heap_ptr, s32 size, u32 num, u32 retaddr);
+void HuMemMemoryFree(void *ptr, u32 retaddr);
+void HuMemMemoryFreeNum(void *heap_ptr, u32 num, u32 retaddr);
+s32 HuMemUsedMemorySizeGet(void *heap_ptr);
+s32 HuMemUsedMemoryBlockGet(void *heap_ptr);
+s32 HuMemMemoryAllocSizeGet(s32 size);
+void HuMemHeapDump(void *heap_ptr, s16 status);
+
+#endif

include/game/object.h

@@ -0,0 +1,103 @@
+#ifndef _GAME_OBJECT_H
+#define _GAME_OBJECT_H
+
+#include "dolphin.h"
+#include "game/process.h"
+#include "game/dvd.h"
+
+#define OVL_DEFINE(name, path) name,
+
+typedef enum {
+    OVL_INVALID = -1,
+    #include "ovl_table.h"
+    OVL_COUNT
+} OverlayID;
+
+#undef OVL_DEFINE
+
+#define OM_STAT_DELETED 0x1
+#define OM_STAT_DISABLED 0x2
+#define OM_STAT_ACTIVE 0x4
+#define OM_STAT_PAUSED 0x10
+#define OM_STAT_NOPAUSE 0x20
+#define OM_STAT_MODEL_PAUSED 0x100
+
+typedef void (*omObjFunc)(struct om_obj_data *);
+
+typedef struct om_ovl_his_data {
+    OverlayID overlay;
+    int event;
+    int stat;
+} omOvlHisData;
+
+typedef struct om_obj_data {
+    u16 stat;
+    s16 next_idx_alloc;
+    s16 prio;
+    s16 prev;
+    s16 next;
+    s16 next_idx;
+    s16 group;
+    u16 group_idx;
+    int unk10;
+    omObjFunc func;
+    Vec trans;
+    Vec rot;
+    Vec scale;
+    u16 mdlcnt;
+    s16 *model;
+    u16 mtncnt;
+    s16 *motion;
+    int work[4];
+    void *data;
+} omObjData;
+
+void omMasterInit(int prio, FileListEntry *ovl_list, int ovl_count, OverlayID start_ovl);
+void omOvlCallEx(OverlayID overlay, s16 arg2, int event, int stat);
+void omOvlGotoEx(OverlayID overlay, s16 arg2, int event, int stat);
+void omOvlReturnEx(s16 level, s16 arg2);
+void omOvlKill(s16 arg);
+void omOvlHisChg(s32 level, OverlayID overlay, int event, int stat);
+omOvlHisData *omOvlHisGet(s32 level);
+Process *omInitObjMan(s16 max_objs, int prio);
+void omDestroyObjMan(void);
+omObjData *omAddObjEx(Process *objman_process, s16 prio, u16 mdlcnt, u16 mtncnt, s16 group, omObjFunc func);
+void omAddMember(Process *objman_process, u16 group, omObjData *object);
+void omDelObjEx(Process *objman_process, omObjData *object);
+void omDelMember(Process *objman_process, omObjData *object);
+void omMakeGroupEx(Process *objman_process, u16 group, u16 max_objs);
+omObjData **omGetGroupMemberListEx(Process *objman_process, s16 group);
+void omSetStatBit(omObjData *obj, u16 stat);
+void omResetStatBit(omObjData *obj, u16 stat);
+void omSetTra(omObjData *obj, float x, float y, float z);
+void omSetRot(omObjData *obj, float x, float y, float z);
+void omSetSca(omObjData *obj, float x, float y, float z);
+void omMain(void);
+void omAllPause(BOOL pause);
+char omPauseChk(void);
+OverlayID omCurrentOvlGet(void);
+
+
+void omDLLDBGOut(void);
+void omDLLInit(FileListEntry *ovl_list);
+int omDLLStart(s16 ovl, s16 dll);
+void omDLLNumEnd(s16 ovl, s16 arg2);
+
+void omSysPauseEnable(BOOL flag);
+
+extern omObjData *omDBGSysKeyObj;
+extern Process *omwatchproc;
+extern OverlayID omnextovl;
+extern OverlayID omcurovl;
+extern int omcurdll;
+extern int omovlhisidx;
+extern int omovlevtno;
+extern int omnextovlevtno;
+extern int omovlstat;
+extern char omUPauseFlag;
+extern s16 omSysExitReq;
+extern s16 omdispinfo;
+extern char omSysPauseEnableFlag;
+extern OverlayID omprevovl;
+
+#endif

include/game/printfunc.h

@@ -0,0 +1,35 @@
+#ifndef _GAME_PRINTFUNC_H
+#define _GAME_PRINTFUNC_H
+
+#include "dolphin.h"
+
+#define FONT_COLOR_BLACK 0
+#define FONT_COLOR_DARK_BLUE 1
+#define FONT_COLOR_DARK_RED 2
+#define FONT_COLOR_DARK_MAGENTA 3
+#define FONT_COLOR_DARK_GREEN 4
+#define FONT_COLOR_DARK_CYAN 5
+#define FONT_COLOR_DARK_YELLOW 6
+#define FONT_COLOR_GRAY 7
+#define FONT_COLOR_TRANSLUCENT_GRAY 8
+#define FONT_COLOR_BLUE 9
+#define FONT_COLOR_RED 10
+#define FONT_COLOR_MAGENTA 11
+#define FONT_COLOR_GREEN 12
+#define FONT_COLOR_CYAN 13
+#define FONT_COLOR_YELLOW 14
+#define FONT_COLOR_WHITE 15
+
+void pfInit(void);
+void pfClsScr(void);
+s16 print8(s16 x, s16 y, float scale, char *str, ...);
+s16 printWin(s16 x, s16 y, s16 w, s16 h, GXColor *color);
+void pfDrawFonts(void);
+
+extern BOOL saftyFrameF;
+extern u16 strlinecnt;
+extern u16 empstrline;
+extern int fontcolor;
+extern u32 procfunc;
+
+#endif

include/game/process.h

@@ -0,0 +1,62 @@
+#ifndef _GAME_PROCESS_H
+#define _GAME_PROCESS_H
+
+#include "dolphin/types.h"
+
+#define PROCESS_STAT_PAUSE 0x1
+#define PROCESS_STAT_UPAUSE 0x2
+#define PROCESS_STAT_PAUSE_EN 0x4
+#define PROCESS_STAT_UPAUSE_EN 0x8
+
+typedef struct jump_buf {
+    u32 lr;
+    u32 cr;
+    u32 sp;
+    u32 r2;
+    u32 pad;
+    u32 regs[19];
+    double flt_regs[19];
+} jmp_buf;
+
+typedef struct process {
+    struct process *next;
+    struct process *prev;
+    struct process *child;
+    struct process *parent;
+    struct process *next_child;
+    struct process *first_child;
+    void *heap;
+    u16 exec;
+    u16 stat;
+    u16 prio;
+    int sleep_time;
+    u32 base_sp;
+    jmp_buf jump;
+    void (*dtor)(void);
+    void *user_data;
+} Process;
+
+void HuPrcInit(void);
+void HuPrcEnd(void);
+Process *HuPrcCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extra_size);
+void HuPrcChildLink(Process *parent, Process *child);
+void HuPrcChildUnlink(Process *process);
+Process *HuPrcChildCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extra_size, Process *parent);
+void HuPrcChildWatch(void);
+Process *HuPrcCurrentGet(void);
+int HuPrcKill(Process *process);
+void HuPrcChildKill(Process *process);
+void HuPrcSleep(int time);
+void HuPrcVSleep(void);
+void HuPrcWakeup(Process *process);
+void HuPrcDestructorSet2(Process *process, void (*func)(void));
+void HuPrcDestructorSet(void (*func)(void));
+void HuPrcCall(int tick);
+void *HuPrcMemAlloc(s32 size);
+void HuPrcMemFree(void *ptr);
+void HuPrcSetStat(Process *process, u16 value);
+void HuPrcResetStat(Process *process, u16 value);
+void HuPrcAllPause(int flag);
+void HuPrcAllUPause(int flag);
+
+#endif

include/game/sprite.h

@@ -0,0 +1,203 @@
+#ifndef _GAME_SPRITE_H
+#define _GAME_SPRITE_H
+
+#include "dolphin.h"
+
+#define SPRITE_MAX 384
+#define SPRITE_GROUP_MAX 256
+
+#define SPRITE_INVALID -1
+#define SPRITE_GROUP_INVALID -1
+
+#define SPRITE_ATTR_PAUSED 0x1
+#define SPRITE_ATTR_LOOP 0x2
+#define SPRITE_ATTR_HIDDEN 0x4
+#define SPIRTE_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 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
+
+#define SPRITE_BMP_FMTMASK 0xF
+#define SPRITE_BMP_ALLOC 0x8000
+#define SPRITE_BMP_NUM_MASK 0x7FFF
+
+#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 {
+    u8 r;
+    u8 g;
+    u8 b;
+    char draw_no;
+    short frame;
+    short bank;
+    short attr;
+    short dirty_flag;
+    short prio;
+    float time;
+    float x;
+    float y;
+    float z_rot;
+    float scale_x;
+    float scale_y;
+    float speed;
+    float a;
+    GXTexWrapMode wrap_s;
+    GXTexWrapMode wrap_t;
+    short tex_scale_x;
+    short tex_scale_y;
+    Mtx *group_mtx;
+    union {
+        AnimData *data;
+        SpriteFunc func;
+    };
+    AnimPatData *pat_data;
+    AnimFrameData *frame_data;
+    short work[4];
+    AnimData *bg;
+    unsigned short bg_bank;
+    short scissor_x;
+    short scissor_y;
+    short scissor_w;
+    short scissor_h;
+} SpriteData;
+
+typedef struct sprite_group_data {
+    short capacity;
+    float x;
+    float y;
+    float z_rot;
+    float scale_x;
+    float scale_y;
+    float center_x;
+    float center_y;
+    short *members;
+    Mtx mtx;
+} SpriteGroupData;
+
+extern SpriteData HuSprData[SPRITE_MAX];
+extern SpriteGroupData HuSprGrpData[SPRITE_GROUP_MAX];
+
+
+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(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);
+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 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);
+
+#endif