mirror/mm
1
0
Fork 0
mirror of https://github.com/zeldaret/mm.git synced 2026-07-10 05:57:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

Animation system updated, some more boot files decompiled (+6%), z_fcurve_data_skelanime decompiled (1 non-matching), some asm files split, etc (#89)

Browse Source 
* Progress on various files

* gfxprint stuff

* split some rodata, add iconv for rodata string parsing

* z_std_dma rodata

* 2 nonmatchings in gfxprint

* mtxuty-cvt ok

* more

* match a function in idle.c

* progress

* Cleanup

* Rename BgPolygon to CollisionPoly

* progress

* some effect stuff

* more effect progress

* updates

* made suggested changes

* z_effect_soft_sprite_old_init mostly ok

* remove old effects enum

* gamealloc.c OK

* added more files

* motor.c almost done

* motor.c OK

* updates

* migration of two files

* listalloc.c oK

* z_fcurve_data_skelanime split

* z_fcurve_data_skelanime.c decompiled

* more files split

* z_malloc.c OK

* contpfs.c OK

* fault.c rodata migrated

* migrated fault_drawer rodata

* update

* update preprocess.py

* renamed functions in z_skelanime

* started z_skelanime cleanup

* like halfway through fixing z_skelanime

* animation system updated to meet oot standards

* remove unused animation structs

* rename matrix structs to fit oot

* Add -woff 712

* fix diff_settings.py because i accidentally broke it before

* fixed merge conflict, doesn't match though

* It matches now

* Updates

* Fixed warnings...added gcc code syntax checking

* Remove gcc check, added in Tharo's PR

* warnings fixed (i think)

* fixed all warnings i think

* ok

* not sure what to do

* Fix all warnings i think (z_en_a_keep needs some file cleanup thouguh)

* it matches if i do this

* remove comment

* accidentally put osPfsFreeBlocks in epilinkhandle.c

* memcmp -> bcmp

* change u32 size to size_t size, delete string.h because it caused unnecessary confusion with defining size_t twice

* format.sh

* MTXMODE_NEW and MTXMODE_APPLY to matrix functions

* Made suggested changes

* pragma sFaultDrawerFont instead of including in repo

* add some functions to functions.h

* Bss reordering fixed in z_collision_check...added hack to disasm.py

* Updated z_en_a_keep.c

* Missed suggestion in EnAObj_Destroy

* .

* update z_fcurve_Data_skelanime and z_skelanime with suggestions

* devmgr.c ok

* minor changes

* Addressed comments

* remove redundant file

* gfxp -> dlist in game.c

* updated actorfixer.py

* fixed warnings in z_malloc

* Change void* back to Actor*

* format

* Add the soft_sprit comments back

* Rename SV->Flex

* remove .common

* run format

* Update src/code/z_skelanime.c

* u32 channel

Co-authored-by: Lucas Shaw <lucas.shaw1123@gmail.com>
Co-authored-by: angie <angheloalf95@gmail.com>
Co-authored-by: Kenix3 <kenixwhisperwind@gmail.com>
This commit is contained in:
Lucas Shaw
2021-10-24 10:59:14 -04:00
committed by GitHub
parent 961913f18f
commit dcf44596d2
181 changed files with 4953 additions and 3658 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/PR/mbi.h
+1 -1
View File
@@ -92,7 +92,7 @@
#define SEGMENT_ADDR(num, off) (((num) << 24) + (off))
#ifndef NULL
#define NULL 0
#define NULL ((void*)0)
#endif
#endif /* !_MBI_H_ */
include/functions.h
+259 -238
View File
@@ -14,22 +14,23 @@ void bootproc(void);
void Idle_ThreadEntry(void* arg);
void ViConfig_UpdateVi(u32 arg0);
void ViConfig_UpdateBlack(void);
s32 DmaMgr_DMARomToRam(u32 src, void* dst, u32 size);
void DmaMgr_DmaCallback0(OSPiHandle* pOParm1, OSIoMesg* pOParm2, s32 OParm3);
s32 DmaMgr_DMARomToRam(u32 src, void* dst, size_t size);
void DmaMgr_DmaCallback0(OSPiHandle* piHandle, OSIoMesg* mb, s32 direction);
DmaEntry* DmaMgr_FindDmaEntry(u32 vromAddr);
u32 DmaMgr_TranslateVromToRom(u32 vromAddr);
s32 DmaMgr_FindDmaIndex(u32 vromAddr);
const char* func_800809F4(u32 param_1);
void DmaMgr_ProcessMsg(DmaRequest* request);
void DmaMgr_ProcessMsg(DmaRequest* req);
void DmaMgr_ThreadEntry(void* arg);
s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, u32 size, UNK_TYPE4 unused, OSMesgQueue* callback, void* callbackMesg);
s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, u32 size);
s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, size_t size, UNK_TYPE4 unused,
OSMesgQueue* callback, void* callbackMesg);
s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, size_t size);
void DmaMgr_Start(void);
void DmaMgr_Stop(void);
void* Yaz0_FirstDMA(void);
void* Yaz0_NextDMA(void* curSrcPos);
s32 Yaz0_DecompressImpl(u8* hdr, u8* dst);
void Yaz0_Decompress(u32 romStart, void* dst, u32 size);
void Yaz0_Decompress(u32 romStart, void* dst, size_t size);
void IrqMgr_AddClient(IrqMgr* irqmgr, IrqMgrClient* add, OSMesgQueue* msgQ);
void IrqMgr_RemoveClient(IrqMgr* irqmgr, IrqMgrClient* remove);
void IrqMgr_SendMesgForClient(IrqMgr* irqmgr, OSMesg msg);
@@ -54,7 +55,7 @@ void rmonPrintf(const char* fmt, ...);
void Fault_SleepImpl(u32 duration);
void Fault_AddClient(FaultClient* client, fault_client_func callback, void* param0, void* param1);
void Fault_RemoveClient(FaultClient* client);
void Fault_AddAddrConvClient(FaultAddrConvClient* client, fault_address_converter_func callback, void* param);
void Fault_AddAddrConvClient(FaultAddrConvClient* client, FaultAddrConvFunc callback, void* param);
void Fault_RemoveAddrConvClient(FaultAddrConvClient* client);
void* Fault_ConvertAddress(void* addr);
void Fault_Sleep(u32 duration);
@@ -75,7 +76,7 @@ void osSyncPrintfThreadContext(OSThread* t);
OSThread* Fault_FindFaultedThread(void);
void Fault_Wait5Seconds(void);
void Fault_WaitForButtonCombo(void);
void Fault_DrawMemDumpPage(char* title, u32* addr, u32 param_3);
void Fault_DrawMemDumpPage(const char* title, u32* addr, u32 param_3);
void Fault_DrawMemDump(u32 pc, u32 sp, u32 unk0, u32 unk1);
void Fault_FindNextStackCall(u32** sp, u32** pc, u32** ra);
void Fault_DrawStackTrace(OSThread* t, u32 flags);
@@ -116,7 +117,7 @@ s32 Load_LoadOverlay(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 allocatedVRa
void* Load_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart);
void Load2_Relocate(u32 allocatedVRamAddr, OverlayRelocationSection* overlayInfo, u32 vRamStart);
s32 Load2_LoadOverlay(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd, u32 allocatedVRamAddr);
void* Load2_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd);
void* Overlay_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd);
void PadUtils_Init(Input* input);
void func_80085150(void);
void PadUtils_ResetPressRel(Input* input);
@@ -155,8 +156,8 @@ void GfxPrint_Open(GfxPrint* printer, Gfx* dList);
Gfx* GfxPrint_Close(GfxPrint* printer);
s32 GfxPrint_VPrintf(GfxPrint* printer, const char* fmt, va_list args);
s32 GfxPrint_Printf(GfxPrint* printer, const char* fmt, ...);
// void MtxConv_F2L(void);
// void MtxConv_L2F(void);
void MtxConv_F2L(MatrixInternal* m1, MtxF* m2);
void MtxConv_L2F(MtxF* m1, MatrixInternal* m2);
void __assert(const char* file, u32 lineNum);
// void func_800862B4(void);
void* SystemArena_MallocMin1(u32 size);
@@ -201,14 +202,14 @@ s32 func_80086D40(f64 param_1);
f64 func_80086D6C(f64 param_1);
s32 func_80086D8C(f32 param_1);
s32 func_80086DAC(f64 param_1);
void* SystemArena_Malloc(u32 size);
void* SystemArena_MallocR(u32 size);
void* SystemArena_Realloc(void* oldPtr, u32 newSize);
void* SystemArena_Malloc(size_t size);
void* SystemArena_MallocR(size_t size);
void* SystemArena_Realloc(void* oldPtr, size_t newSize);
void SystemArena_Free(void* ptr);
void* SystemArena_Calloc(u32 elements, u32 size);
void SystemArena_AnalyzeArena(u32* maxFreeBlock, u32* bytesFree, u32* bytesAllocated);
void* SystemArena_Calloc(u32 elements, size_t size);
void SystemArena_AnalyzeArena(size_t* maxFreeBlock, size_t* bytesFree, size_t* bytesAllocated);
u32 SystemArena_CheckArena(void);
void SystemArena_InitArena(void* start, u32 size);
void SystemArena_InitArena(void* start, size_t size);
void SystemArena_Cleanup(void);
u8 SystemArena_IsInitialized(void);
s32 Rand_Next(void);
@@ -223,15 +224,15 @@ void ArenaImpl_LockInit(Arena* heap);
void ArenaImpl_Lock(Arena* heap);
void ArenaImpl_Unlock(Arena* heap);
ArenaNode* ArenaImpl_GetLastBlock(Arena* param_1);
void __osMallocInit(Arena* heap, void* heapBase, u32 heapSize);
void __osMallocInit(Arena* heap, void* heapBase, size_t heapSize);
void __osMallocAddBlock(Arena* heap, void* start, s32 size);
void __osMallocCleanup(Arena* heap);
u8 __osMallocIsInitalized(Arena* heap);
void* __osMalloc(Arena* heap, u32 size);
void* __osMallocR(Arena* heap, u32 size);
void* __osMalloc(Arena* heap, size_t size);
void* __osMallocR(Arena* heap, size_t size);
void __osFree(Arena* heap, void* ptr);
void* __osRealloc(Arena* heap, void* oldPtr, u32 newSize);
void __osAnalyzeArena(Arena* heap, u32* maxFreeBlock, u32* bytesFree, u32* bytesAllocated);
void* __osRealloc(Arena* heap, void* oldPtr, size_t newSize);
void __osAnalyzeArena(Arena* heap, size_t* maxFreeBlock, size_t* bytesFree, size_t* bytesAllocated);
u32 __osCheckArena(Arena* heap);
void* proutSprintf(void* s, const char* buf, size_t n);
s32 vsprintf(char* dst, char* fmt, va_list args);
@@ -282,7 +283,7 @@ void __osDequeueThread(OSThread** param_1, OSThread* param_2);
void osDestroyThread(OSThread* puParm1);
// void __osVoiceCheckResult(void);
void bzero(void* begin, s32 length);
// void osSetRumble(void);
s32 osSetRumble(OSPfs* pfs, u32 vibrate);
// void osSetUpMempakWrite(void);
// void osProbeRumblePak(void);
void __osSiCreateAccessQueue(void);
@@ -306,9 +307,9 @@ void __osInitialize_autodetect(void);
void* osViGetNextFramebuffer(void);
void guPerspectiveF(float mf[4][4], u16* perspNorm, f32 fovy, f32 aspect, f32 near, f32 far, f32 scale);
void guPerspective(Mtx* m, u16* perspNorm, f32 fovy, f32 aspect, f32 near, f32 far, f32 scale);
s32 __osSpRawStartDma(s32 direction, void* devAddr, void* dramAddr, u32 size);
s32 __osSpRawStartDma(s32 direction, void* devAddr, void* dramAddr, size_t size);
s32 __osSiRawStartDma(s32 direction, void* dramAddr);
// void osEPiLinkHandle(void);
s32 osEPiLinkHandle(OSPiHandle* handle);
void osViBlack(u8 active);
s32 __osSiRawReadIo(u32 devAddr, u32* data);
OSId osGetThreadId(OSThread* t);
@@ -334,14 +335,14 @@ void __osPiGetAccess(void);
void __osPiRelAccess(void);
void __osDevMgrMain(void* arg);
// void func_8008C640(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE1 param_5, UNK_TYPE1 param_6, UNK_TYPE1 param_7, UNK_TYPE1 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10, UNK_TYPE4 param_11, UNK_TYPE4 param_12, UNK_TYPE4 param_13, UNK_TYPE4 param_14, UNK_TYPE4 param_15, UNK_TYPE4 param_16, UNK_TYPE4 param_17, UNK_TYPE4 param_18);
s32 osPiRawStartDma(s32 direction, u32 devAddr, void* dramAddr, u32 size);
// void __osSumcalc(void);
// void __osIdCheckSum(void);
// void __osRepairPackId(void);
s32 __osPiRawStartDma(s32 direction, u32 devAddr, void* dramAddr, size_t size);
u16 __osSumcalc(u8* ptr, s32 length);
s32 __osIdCheckSum(u16* ptr, u16* checkSum, u16* idSum);
s32 __osRepairPackId(OSPfs* pfs, __OSPackId* badid, __OSPackId* newid);
// void __osCheckPackId(void);
// void __osGetId(void);
// void __osCheckId(void);
// void __osPfsRWInode(void);
s32 __osCheckId(OSPfs* pfs);
s32 __osPfsRWInode(OSPfs* pfs, __OSInode* inode, u8 flag, u8 bank);
u32 osGetCount(void);
void guMtxL2F(MtxF* m1, Mtx* m2);
u32 osGetMemSize(void);
@@ -377,11 +378,11 @@ s32 __osSiDeviceBusy(void);
s32 osJamMesg(OSMesgQueue* mq, OSMesg msg, s32 flag);
void osSetThreadPri(OSThread* t, OSPri pri);
OSPri osGetThreadPri(OSThread* t);
s32 osEPiRawReadIo(OSPiHandle* handle, u32 devAddr, u32* data);
s32 __osEPiRawReadIo(OSPiHandle* handle, u32 devAddr, u32* data);
void osViSwapBuffer(void* frameBufPtr);
void guPositionF(float mf[4][4], f32 r, f32 p, f32 h, f32 s, f32 x, f32 y, f32 z);
void guPosition(Mtx* m, f32 r, f32 p, f32 h, f32 s, f32 x, f32 y, f32 z);
s32 osEPiRawStartDma(OSPiHandle*, s32, u32, void*, u32);
s32 __osEPiRawStartDma(OSPiHandle* handle, s32 direction, u32 cartAddr, void* dramAddr, size_t size);
OSYieldResult osSpTaskYielded(OSTask* task);
s32 bcmp(void* __s1, void* __s2, size_t __n);
OSTime osGetTime(void);
@@ -426,7 +427,7 @@ s32 osPfsIsPlug(OSMesgQueue* queue, u8* pattern);
s32 __osVoiceGetStatus(OSMesgQueue* mq, s32 port, u8* status);
OSPiHandle* osCartRomInit(void);
// void guS2DInitBg(void);
// s32 __osPfsSelectBank(OSPfs* pfs, UNK_TYPE4 param_2);
s32 __osPfsSelectBank(OSPfs* pfs, u8 bank);
s32 osContSetCh(u8 ch);
u32 __osSetFpcCsr(u32 value);
u32 __osGetFpcCsr(void);
@@ -483,16 +484,11 @@ void __osSetHWIntrRoutine(s32 idx, OSMesgQueue* queue, OSMesg msg);
u32 __osGetWatchLo(void);
void __osSetWatchLo(u32 value);
f32 fmodf(f32 dividend, f32 divisor);
void* __osMemset(void* ptr, s32 val, u32 size);
void* __osMemset(void* ptr, s32 val, size_t size);
s32 __osStrcmp(const char* str1, const char* str2);
char* __osStrcpy(char* dst, const char* src);
void* __osMemcpy(void* dst, void* src, size_t size);
void EnAObj_Init(ActorEnAObj* this, GlobalContext* globalCtx);
void EnAObj_Destroy(ActorEnAObj* this, GlobalContext* globalCtx);
void EnAObj_Update1(ActorEnAObj* this, GlobalContext* globalCtx);
void EnAObj_Update2(ActorEnAObj* this, GlobalContext* globalCtx);
void EnAObj_Update(ActorEnAObj* this, GlobalContext* globalCtx);
void EnAObj_Draw(ActorEnAObj* this, GlobalContext* globalCtx);
// void EnItem00_SetObject(EnItem00* this, GlobalContext* globalCtx, f32* shadowOffset, f32* shadowScale);
// void EnItem00_Init(Actor* thisx, GlobalContext* globalCtx);
// void EnItem00_Destroy(Actor* thisx, GlobalContext* globalCtx);
@@ -681,10 +677,10 @@ void func_800B3030(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f*
// void func_800B31BC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6);
void EffectSsIceSmoke_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 scale);
// void EffectSsIceBlock_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5);
void FlagSet_Update(GameState* gamestate);
void FlagSet_Update(GameState* gameState);
void FlagSet_Draw(GameState* gameState);
void DLF_LoadGameState(GameStateOverlay* gameState);
void DLF_FreeGameState(GameStateOverlay* gameState);
void Overlay_LoadGameState(GameStateOverlay* gameState);
void Overlay_FreeGameState(GameStateOverlay* gameState);
void Actor_PrintLists(ActorContext* actorCtx);
void ActorShape_Init(ActorShape* actorShape, f32 yOffset, ActorShadowFunc func, f32 scale);
void ActorShadow_Draw(Actor* actor, Lights* mapper, GlobalContext* globalCtx, Gfx* displayList, Color_RGBA8* color);
@@ -1690,14 +1686,16 @@ s16 ActorCutscene_GetCurrentCamera(s16 index);
s32 func_800F22C4(s16 param_1, Actor* actor);
void ActorCutscene_SetReturnCamera(s16 index);
// void func_800F23E0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800F2478(void);
// void func_800F2620(void);
// void func_800F2650(void);
// void func_800F26C0(void);
// void func_800F26F0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800F2728(void);
// void func_800F29A0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void func_800F2CD8(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
f32 func_800F2478(f32 target, TransformData* transData, s32 refIdx);
void SkelCurve_Clear(SkelAnimeCurve* skelCurve);
s32 SkelCurve_Init(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve, SkelCurveLimbList* limbListSeg,
TransformUpdateIndex* transUpdIdx);
void SkelCurve_Destroy(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve);
void SkelCurve_SetAnim(SkelAnimeCurve* skelCurve, TransformUpdateIndex* transUpdIdx, f32 arg2, f32 animFinalFrame,
f32 animCurFrame, f32 animSpeed);
s32 SkelCurve_Update(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve);
void SkelCurve_Draw(Actor* actor, GlobalContext* globalCtx, SkelAnimeCurve* skelCurve,
OverrideCurveLimbDraw overrideLimbDraw, PostCurveLimbDraw postLimbDraw, s32 lod, Actor* thisx);
void FireObj_InitWithParams(GlobalContext* globalCtx, FireObj* fire, FireObjInitParams* init);
void FireObj_SetState(FireObj* fire, f32 dynamicSizeStep, u8 newState);
void FireObj_SetPosition(FireObj* fire, Vec3f* pos);
@@ -1919,16 +1917,16 @@ Lights* Lights_NewAndDraw(GraphicsContext* gfxCtx, u8 ambientR, u8 ambientG, u8
Lights* Lights_New(GraphicsContext* gfxCtx, u8 ambientR, u8 ambientG, u8 ambientB);
void Lights_GlowCheck(GlobalContext* globalCtx);
void Lights_DrawGlow(GlobalContext* globalCtx);
void* zelda_malloc(u32 size);
void* zelda_mallocR(u32 size);
void* zelda_realloc(void* oldPtr, u32 newSize);
void zelda_free(void* param_1);
void* zelda_calloc(u32 num, u32 size);
void MainHeap_AnalyzeArena(u32* maxFreeBlock, u32* bytesFree, u32* bytesAllocated);
// s32 MainHeap_Check(void);
void MainHeap_Init(u32 base, u32 size);
// void MainHeap_Cleanup(void);
// u32 MainHeap_IsInitialized(void);
void* ZeldaArena_Malloc(size_t size);
void* ZeldaArena_MallocR(size_t size);
void* ZeldaArena_Realloc(void* oldPtr, size_t newSize);
void ZeldaArena_Free(void* param_1);
void* ZeldaArena_Calloc(u32 num, size_t size);
void ZeldaArena_GetSizes(size_t* maxFreeBlock, size_t* bytesFree, size_t* bytesAllocated);
void ZeldaArena_Check();
void ZeldaArena_Init(void* start, size_t size);
void ZeldaArena_Cleanup();
u8 ZeldaArena_IsInitialized();
// void func_80102E40(void);
// void func_80102E90(void);
// void func_80102EA4(void);
@@ -2442,7 +2440,7 @@ void func_8012F1BC(s16 sceneIndex);
s16 func_8012F22C(s16 sceneIndex);
void func_8012F278(GlobalContext* globalCtx);
s32 Object_Spawn(ObjectContext* objectCtx, s16 id);
void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx);
void Object_InitBank(GameState* gameState, ObjectContext* objectCtx);
void Object_UpdateBank(ObjectContext* objectCtx);
s32 Object_GetIndex(ObjectContext* objectCtx, s16 id);
s32 Object_IsLoaded(ObjectContext* objectCtx, s32 index);
@@ -2461,7 +2459,7 @@ void Scene_HeaderCmdObjectList(GlobalContext* globalCtx, SceneCmd* cmd);
void Scene_HeaderCmdLightList(GlobalContext* globalCtx, SceneCmd* cmd);
void Scene_HeaderCmdPathList(GlobalContext* globalCtx, SceneCmd* cmd);
void Scene_HeaderCmdTransiActorList(GlobalContext* globalCtx, SceneCmd* cmd);
void Door_InitContext(GameState* gamestate, DoorContext* doorCtx);
void Door_InitContext(GameState* gameState, DoorContext* doorCtx);
void Scene_HeaderCmdEnvLightSettings(GlobalContext* globalCtx, SceneCmd* cmd);
s32 Scene_LoadAreaTextures(GlobalContext* globalCtx, s32 fileIndex);
void Scene_HeaderCmdSkyboxSettings(GlobalContext* globalCtx, SceneCmd* cmd);
@@ -2544,96 +2542,115 @@ s32 Entrance_GetTransitionFlags(u16 entranceIndex);
// void func_80132E9C(void);
// void func_80132FDC(void);
// void func_80133000(void);
s32 func_80133038(GlobalContext* globalCtx, UNK_PTR arg1, struct_80133038_arg2* arg2);
void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, s32 dListIndex);
void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, s32 dListIndex);
void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDrawSV overrideLimbDraw, PostLimbDrawSV postLimbDraw, Actor* actor, s32 dListIndex, RSPMatrix** mtx);
void SkelAnime_LodDrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount, OverrideLimbDrawSV overrideLimbDraw, PostLimbDrawSV postLimbDraw, Actor* actor, s32 dListIndex);
void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor);
void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor);
void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, RSPMatrix** limbMatricies);
void SkelAnime_DrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor);
void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, UnkActorDraw unkDraw, Actor* actor, RSPMatrix** mtx);
void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount, OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, UnkActorDraw unkDraw, Actor* actor);
void SkelAnime_AnimateFrame(AnimationHeader* animationSeg, s32 currentFrame, s32 limbCount, Vec3s* dst);
s16 SkelAnime_GetTotalFrames(AnimationHeaderCommon* animationSeg);
s16 SkelAnime_GetFrameCount(AnimationHeaderCommon* animationSeg);
Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, Gfx* gfx);
Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, Gfx* gfx);
Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, RSPMatrix** mtx, Gfx* gfx);
Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount, OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, Gfx* gfx);
s32 func_80134FFC(s32 arg0, s32 arg1, Vec3s* dst);
s16 func_801353D4(AnimationHeaderCommon* animationSeg);
s16 SkelAnime_GetTotalFrames2(AnimationHeaderCommon* animationSeg);
s16 SkelAnime_GetFrameCount2(AnimationHeaderCommon* animationSeg);
void SkelAnime_InterpolateVec3s(s32 limbCount, Vec3s* dst, Vec3s* vec2, Vec3s* vec3, f32 unkf);
void SkelAnime_AnimationCtxReset(AnimationContext* animationCtx);
void func_801358D4(GlobalContext* globalCtx);
void func_801358F4(GlobalContext* globalCtx);
AnimationEntry* SkelAnime_NextEntry(AnimationContext* animationCtx, AnimationType type);
void SkelAnime_LoadLinkAnimetion(GlobalContext* globalCtx, LinkAnimationHeader* linkAnimetionSeg, s32 frame, s32 limbCount, void* ram);
void SkelAnime_LoadAnimationType1(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src);
void SkelAnime_LoadAnimationType2(GlobalContext* globalCtx, s32 limbCount, Vec3s* arg2, Vec3s* arg3, f32 arg4);
void SkelAnime_LoadAnimationType3(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index);
void SkelAnime_LoadAnimationType4(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index);
void SkelAnime_LoadAnimationType5(GlobalContext* globalCtx, Actor* actor, SkelAnime* skelAnime, f32 arg3);
void SkelAnime_LinkAnimetionLoaded(GlobalContext* globalCtx, AnimationEntryType0* entry);
void SkelAnime_AnimationType1Loaded(GlobalContext* globalCtx, AnimationEntryType1* entry);
void SkelAnime_AnimationType2Loaded(GlobalContext* globalCtx, AnimationEntryType2* entry);
void SkelAnime_AnimationType3Loaded(GlobalContext* globalCtx, AnimationEntryType3* entry);
void SkelAnime_AnimationType4Loaded(GlobalContext* globalCtx, AnimationEntryType4* entry);
void SkelAnime_AnimationType5Loaded(GlobalContext* globalCtx, AnimationEntryType5* entry);
void func_80135EE8(GlobalContext* globalCtx, AnimationContext* animationCtx);
void SkelAnime_InitLinkAnimetion(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg, LinkAnimationHeader* linkAnimationHeaderSeg, s32 flags, Vec3s* limbDrawTbl, Vec3s* transitionDrawTbl, s32 limbBufCount);
void func_801360A8(SkelAnime* skelAnime);
s32 func_801360E0(GlobalContext* globalCtx, SkelAnime* skelAnime);
s32 func_80136104(GlobalContext* globalCtx, SkelAnime* skelAnime);
void func_801361BC(GlobalContext* globalCtx, SkelAnime* skelAnime);
s32 func_80136288(GlobalContext* globalCtx, SkelAnime* skelAnime);
s32 func_8013631C(GlobalContext* globalCtx, SkelAnime* skelAnime);
void SkelAnime_SetTransition(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 transitionRate);
void SkelAnime_ChangeLinkAnim(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed, f32 frame, f32 frameCount, u8 animationMode, f32 transitionRate);
void SkelAnime_ChangeLinkAnimDefaultStop(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg);
void SkelAnime_ChangeLinkAnimPlaybackStop(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed);
void SkelAnime_ChangeLinkAnimDefaultRepeat(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg);
void SkelAnime_ChangeLinkAnimPlaybackRepeat(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed);
void func_8013670C(GlobalContext* globalCtx, SkelAnime* skelAnime);
void func_8013673C(GlobalContext* globalCtx, SkelAnime* skelAnime);
void func_8013676C(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 frame);
void func_801367B0(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 frame);
void func_801367F4(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 frame);
void func_8013682C(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 transitionFrame, LinkAnimationHeader* LinkAnimationHeaderSeg2, f32 frame, f32 transitionRate, Vec3s* limbDrawTbl);
void func_801368CC(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg, f32 transitionFrame, LinkAnimationHeader* LinkAnimationHeaderSeg2, f32 frame, f32 transitionRate, Vec3s* limbDrawTbl);
void SkelAnime_SetModeStop(SkelAnime* skelAnime);
s32 func_80136990(SkelAnime* skelAnime, f32 arg1, f32 updateRate);
s32 func_80136A48(SkelAnime* skelAnime, f32 arg1);
void SkelAnime_Init(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg, AnimationHeader* animationSeg, Vec3s* limbDrawTbl, Vec3s* transitionDrawTable, s32 limbCount);
void SkelAnime_InitSV(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg, AnimationHeader* animationSeg, Vec3s* limbDrawTbl, Vec3s* transitionDrawTable, s32 limbCount);
UNK_TYPE func_80133038(GlobalContext* globalCtx, UNK_TYPE* arg1, struct_80133038_arg2* arg2);
void SkelAnime_DrawLimbLod(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable, OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor, s32 lod);
void SkelAnime_DrawLod(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor, s32 lod);
void SkelAnime_DrawFlexLimbLod(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable, OverrideLimbDrawFlex overrideLimbDraw, PostLimbDrawFlex postLimbDraw, Actor* actor, s32 lod, Mtx** mtx);
void SkelAnime_DrawFlexLod(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
OverrideLimbDrawFlex overrideLimbDraw, PostLimbDrawFlex postLimbDraw, Actor* actor,
s32 lod);
void SkelAnime_DrawLimbOpa(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor);
void SkelAnime_DrawOpa(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable,
OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor);
void SkelAnime_DrawFlexLimbOpa(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor,
Mtx** limbMatricies);
void SkelAnime_DrawFlexOpa(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor);
void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, UnkActorDraw unkDraw, Actor* actor,
Mtx** mtx);
void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, UnkActorDraw unkDraw, Actor* actor);
void SkelAnime_GetFrameData(AnimationHeader* animationSeg, s32 currentFrame, s32 limbCount, Vec3s* dst);
s16 Animation_GetLength(void* animation);
s16 Animation_GetLastFrame(void* animation);
Gfx* SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, Gfx* gfx);
Gfx* SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable,
OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, Gfx* gfx);
Gfx* SkelAnime_DrawFlexLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor,
Mtx** mtx, Gfx* gfx);
Gfx* SkelAnime_DrawFlex(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, Gfx* gfx);
s16 SkelAnime_GetFrameData2(LegacyAnimationHeader* animation, s32 frame, Vec3s* frameTable);
s16 Animation_GetLimbCount2(LegacyAnimationHeader* animation);
s16 Animation_GetLength2(LegacyAnimationHeader* animation);
s16 Animation_GetLastFrame2(LegacyAnimationHeader* animation);
void SkelAnime_InterpFrameTable(s32 limbCount, Vec3s* dst, Vec3s* vec2, Vec3s* vec3, f32 unkf);
void AnimationContext_Reset(AnimationContext* animationCtx);
void AnimationContext_SetNextQueue(GlobalContext* globalCtx);
void AnimationContext_DisableQueue(GlobalContext* globalCtx);
AnimationEntry* AnimationContext_AddEntry(AnimationContext* animationCtx, AnimationType type);
void AnimationContext_SetLoadFrame(GlobalContext* globalCtx, LinkAnimationHeader* animation, s32 frame,
s32 limbCount, Vec3s* frameTable);
void AnimationContext_SetCopyAll(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src);
void AnimationContext_SetInterp(GlobalContext* globalCtx, s32 limbCount, Vec3s* arg2, Vec3s* arg3, f32 arg4);
void AnimationContext_SetCopyTrue(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index);
void AnimationContext_SetCopyFalse(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index);
void AnimationContext_SetMoveActor(GlobalContext* globalCtx, Actor* actor, SkelAnime* skelAnime, f32 arg3);
void AnimationContext_LoadFrame(GlobalContext* globalCtx, AnimationEntryData* data);
void AnimationContext_CopyAll(GlobalContext* globalCtx, AnimationEntryData* data);
void AnimationContext_Interp(GlobalContext* globalCtx, AnimationEntryData* data);
void AnimationContext_CopyTrue(GlobalContext* globalCtx, AnimationEntryData* data);
void AnimationContext_CopyFalse(GlobalContext* globalCtx, AnimationEntryData* data);
void AnimationContext_MoveActor(GlobalContext* globalCtx, AnimationEntryData* data);
void AnimationContext_Update(GlobalContext* globalCtx, AnimationContext* animationCtx);
void SkelAnime_InitLink(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg,
LinkAnimationHeader* animation, s32 flags, Vec3s* jointTable,
Vec3s* morphTable, s32 limbBufCount);
void LinkAnimation_SetUpdateFunction(SkelAnime* skelAnime);
s32 LinkAnimation_Update(GlobalContext* globalCtx, SkelAnime* skelAnime);
s32 LinkAnimation_Morph(GlobalContext* globalCtx, SkelAnime* skelAnime);
void LinkAnimation_AnimateFrame(GlobalContext* globalCtx, SkelAnime* skelAnime);
s32 LinkAnimation_Loop(GlobalContext* globalCtx, SkelAnime* skelAnime);
s32 LinkAnimation_Once(GlobalContext* globalCtx, SkelAnime* skelAnime);
void Animation_SetMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 transitionRate);
void LinkAnimation_Change(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 playbackSpeed, f32 frame, f32 frameCount, u8 animationMode, f32 transitionRate);
void LinkAnimation_PlayOnce(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg);
void LinkAnimation_PlayOnceSetSpeed(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 playbackSpeed);
void LinkAnimation_PlayLoop(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg);
void LinkAnimation_PlayLoopSetSpeed(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 playbackSpeed);
void LinkAnimation_CopyJointToMorph(GlobalContext* globalCtx, SkelAnime* skelAnime);
void LinkAnimation_CopyMorphToJoint(GlobalContext* globalCtx, SkelAnime* skelAnime);
void LinkAnimation_LoadToMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 frame);
void LinkAnimation_LoadToJoint(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 frame);
void LinkAnimation_InterpJointMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 frame);
void LinkAnimation_BlendToJoint(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 transitionFrame, LinkAnimationHeader* linkAnimetionEntrySeg2, f32 frame, f32 transitionRate, Vec3s* jointTable);
void LinkAnimation_BlendToMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg, f32 transitionFrame, LinkAnimationHeader* linkAnimetionEntrySeg2, f32 frame, f32 transitionRate, Vec3s* jointTable);
void LinkAnimation_EndLoop(SkelAnime* skelAnime);
s32 Animation_OnFrameImpl(SkelAnime* skelAnime, f32 arg1, f32 updateRate);
s32 LinkAnimation_OnFrame(SkelAnime* skelAnime, f32 arg1);
void SkelAnime_Init(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg, AnimationHeader* animationSeg, Vec3s* jointTable, Vec3s* morphTable, s32 limbCount);
void SkelAnime_InitFlex(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg,
AnimationHeader* animation, Vec3s* jointTable, Vec3s* morphTable, s32 limbCount);
void SkelAnime_InitSkin(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg, AnimationHeader* animationSeg);
void func_80136C84(SkelAnime* skelAnime);
s32 SkelAnime_FrameUpdateMatrix(SkelAnime* skelAnime);
s32 func_80136CF4(SkelAnime* skelAnime);
s32 func_80136D98(SkelAnime* skelAnime);
void func_80136F04(SkelAnime* skelAnime);
s32 func_8013702C(SkelAnime* skelAnime);
s32 func_801370B0(SkelAnime* skelAnime);
s32 func_8013713C(SkelAnime* skelAnime);
void SkelAnime_ChangeAnimImpl(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame, f32 frameCount, u8 animationType, f32 transitionRate, s8 unk2);
void SkelAnime_ChangeAnim(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame, f32 frameCount, u8 mode, f32 transitionRate);
void SkelAnime_ChangeAnimDefaultStop(SkelAnime* skelAnime, AnimationHeader* animationSeg);
void SkelAnime_ChangeAnimTransitionStop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate);
void SkelAnime_ChangeAnimPlaybackStop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed);
void SkelAnime_ChangeAnimDefaultRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg);
void SkelAnime_ChangeAnimTransitionRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate);
void SkelAnime_ChangeAnimPlaybackRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed);
void SkelAnime_AnimSetStop(SkelAnime* skelAnime);
void SkelAnime_AnimReverse(SkelAnime* skelAnime);
void func_80137674(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* index);
void func_801376DC(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* arg3);
void func_80137748(SkelAnime* skelAnime, Vec3f* pos, s16 angle);
s32 func_801378B8(SkelAnime* skelAnime, f32 arg1);
void SkelAnime_SetUpdate(SkelAnime* skelAnime);
s32 SkelAnime_Update(SkelAnime* skelAnime);
s32 SkelAnime_Morph(SkelAnime* skelAnime);
s32 SkelAnime_MorphTaper(SkelAnime* skelAnime);
void SkelAnime_AnimateFrame(SkelAnime* skelAnime);
s32 SkelAnime_LoopFull(SkelAnime* skelAnime);
s32 SkelAnime_LoopPartial(SkelAnime* skelAnime);
s32 SkelAnime_Once(SkelAnime* skelAnime);
void Animation_ChangeImpl(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame, f32 frameCount, u8 animationType, f32 transitionRate, s8 unk2);
void Animation_Change(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame, f32 frameCount, u8 mode, f32 transitionRate);
void Animation_PlayOnce(SkelAnime* skelAnime, AnimationHeader* animationSeg);
void Animation_MorphToPlayOnce(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate);
void Animation_PlayOnceSetSpeed(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed);
void Animation_PlayLoop(SkelAnime* skelAnime, AnimationHeader* animationSeg);
void Animation_MorphToLoop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate);
void Animation_PlayLoopSetSpeed(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed);
void Animation_EndLoop(SkelAnime* skelAnime);
void Animation_Reverse(SkelAnime* skelAnime);
void SkelAnime_CopyFrameTableTrue(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* index);
void SkelAnime_CopyFrameTableFalse(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* arg3);
void SkelAnime_UpdateTranslation(SkelAnime* skelAnime, Vec3f* pos, s16 angle);
s32 Animation_OnFrame(SkelAnime* skelAnime, f32 arg1);
void SkelAnime_Free(SkelAnime* skelAnime, GlobalContext* globalCtx);
void SkelAnime_CopyVec3s(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src);
void SkelAnime_CopyFrameTable(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src);
// void func_80137970(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_80137B34(void);
// void func_80137EBC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
@@ -2683,7 +2700,7 @@ s16 func_8013A504(s16 val);
s32 func_8013A530(GlobalContext* globalCtx, Actor* actor, s32 flag, Vec3f* pos, Vec3s* rot, f32 distanceMin, f32 distanceMax, s16 angleError);
// void func_8013A7C0(void);
// void func_8013A860(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10);
Gfx* func_8013AB00(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount, void* func1, void* func2, void* func3, Actor* actor, Gfx* gfx);
Gfx* func_8013AB00(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount, void* func1, void* func2, void* func3, Actor* actor, Gfx* gfx);
s32 func_8013AD6C(GlobalContext* globalCtx);
// void func_8013AD9C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
void func_8013AED4(u16* param_1, u16 param_2, u16 param_3);
@@ -2765,7 +2782,7 @@ s32 View_SetQuakeSpeed(View* view, f32 speed);
s32 View_InitCameraQuake(View* view);
s32 View_ClearQuake(View* view);
s32 View_SetQuake(View* view, Vec3f rot, Vec3f scale, f32 speed);
s32 View_StepQuake(View* view, RSPMatrix* matrix);
s32 View_StepQuake(View* view, Mtx* matrix);
void View_RenderView(View* view, s32 uParm2);
s32 View_RenderToPerspectiveMatrix(View* view);
s32 View_RenderToOrthographicMatrix(View* view);
@@ -2803,11 +2820,12 @@ void VisMono_Draw(void* arg0, Gfx** gfx, u32 arg2);
void func_801420C0(void* arg0);
void func_801420F4(void* arg0);
void func_80142100(void* arg0, Gfx** gfx, u32 arg2);
s32 func_80142440(SkyboxContext* skyboxCtx, Vtx* vtx, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8);
void func_80143148(SkyboxContext* skyboxCtx, s32 arg1);
void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType);
s32 func_80142440(SkyboxContext* skyboxCtx, Vtx* vtx, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7,
s32 arg8);
void func_80143148(SkyboxContext* skyboxCtx, s32 arg1);
void func_801431E8(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyType);
void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyType);
void func_801434E4(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType);
void func_801434E4(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyType);
// void func_801435A0(void);
// void func_80143624(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE1 param_5, UNK_TYPE1 param_6, UNK_TYPE1 param_7);
// void func_80143668(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
@@ -2826,13 +2844,13 @@ void Sram_InitDebugSave(void);
// void func_80144E78(void);
// void func_8014546C(void);
// void func_80145698(void);
void func_801457CC(GameState* gamestate, SramContext* param_2);
void func_801457CC(GameState* gameState, SramContext* param_2);
void func_80146580(s32 param_1, SramContext* param_2, s32 param_3);
// void func_80146628(void);
// void func_80146AA0(void);
// void func_80146DF8(void);
void func_80146E40(GameState* gameState, SramContext* sramCtx);
void Sram_Alloc(GameState* gamestate, SramContext* sramCtx);
void Sram_Alloc(GameState* gameState, SramContext* sramCtx);
// void func_80146EBC(SramContext* param_1, UNK_TYPE4 param_2, UNK_TYPE4 param_3);
// void func_80146EE8(void);
// void func_80146F5C(void);
@@ -3101,8 +3119,9 @@ void PreRender_ApplyFiltersSlowlyInit(PreRender* this);
void PreRender_ApplyFiltersSlowlyDestroy(PreRender* this);
void func_801720C4(PreRender* this);
void func_801720FC(PreRenderParams* params, Gfx** gfxp);
void func_80172758(Gfx** gfxp, void* timg, void* tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 tt, u16 arg8, f32 x, f32 y, f32 xScale, f32 yScale, u32 flags);
void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size);
void func_80172758(Gfx** gfxp, void* timg, void* tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 tt, u16 arg8, f32 x,
f32 y, f32 xScale, f32 yScale, u32 flags);
void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, size_t size);
void THGA_Dt(TwoHeadGfxArena* thga);
u32 THGA_IsCrash(TwoHeadGfxArena* thga);
void THGA_Init(TwoHeadGfxArena* thga);
@@ -3113,7 +3132,7 @@ Gfx* THGA_GetTail(TwoHeadGfxArena* thga);
Gfx* THGA_AllocStartArray8(TwoHeadGfxArena* thga, u32 count);
Gfx* THGA_AllocStart8(TwoHeadGfxArena* thga);
Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga);
Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size);
Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, size_t size);
Gfx* THGA_AllocEndArray64(TwoHeadGfxArena* thga, u32 count);
Gfx* THGA_AllocEnd64(TwoHeadGfxArena* thga);
Gfx* THGA_AllocEndArray16(TwoHeadGfxArena* thga, u32 count);
@@ -3121,15 +3140,15 @@ Gfx* THGA_AllocEnd16(TwoHeadGfxArena* thga);
void* THA_GetHead(TwoHeadArena* tha);
void THA_SetHead(TwoHeadArena* tha, void* start);
void* THA_GetTail(TwoHeadArena* tha);
void* THA_AllocStart(TwoHeadArena* tha, u32 size);
void* THA_AllocStart(TwoHeadArena* tha, size_t size);
void* THA_AllocStart1(TwoHeadArena* tha);
void* THA_AllocEnd(TwoHeadArena* tha, u32 size);
void* THA_AllocEndAlign16(TwoHeadArena* tha, u32 size);
void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask);
void* THA_AllocEnd(TwoHeadArena* tha, size_t size);
void* THA_AllocEndAlign16(TwoHeadArena* tha, size_t size);
void* THA_AllocEndAlign(TwoHeadArena* tha, size_t size, u32 mask);
s32 THA_GetSize(TwoHeadArena* tha);
u32 THA_IsCrash(TwoHeadArena* tha);
void THA_Init(TwoHeadArena* tha);
void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size);
void THA_Ct(TwoHeadArena* tha, void* ptr, size_t size);
void THA_Dt(TwoHeadArena* tha);
void func_80172BC0(void);
void func_80172C30(AudioMgr* audioMgr);
@@ -3145,46 +3164,46 @@ void TitleSetup_Init(GameState* gameState);
void Game_UpdateFramerateVariables(s32 divisor);
void Game_SetFramerateDivisor(GameState* gameState, s32 divisor);
void GameState_SetFBFilter(Gfx** gfx, u32 arg1);
void Game_Nop80173534(GameState* gamestate);
void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx);
void Game_ResetSegments(GraphicsContext* gfxCtx);
void func_801736DC(GraphicsContext* gfxCtx);
void Game_UpdateInput(GameState* gamestate);
void Game_Update(GameState* gamestate);
void Game_IncrementFrameCount(GameState* gamestate);
void Game_InitHeap(GameState* gamestate, u32 size);
void Game_ResizeHeap(GameState* gamestate, u32 size);
void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsContext* gfxCtx);
void Game_StateFini(GameState* gamestate);
GameStateFunc Game_GetNextStateInit(GameState* gamestate);
u32 Game_GetNextStateSize(GameState* gamestate);
u32 Game_GetShouldContinue(GameState* gamestate);
s32 Game_GetHeapFreeSize(GameState* gamestate);
s32 func_80173B48(GameState* gamestate);
GameAlloc* func_80173BF0(GameAlloc* heap);
void* Gamealloc_Alloc(GameAlloc* heap, u32 size);
void Gamealloc_Free(GameAlloc* heap, void* ptr);
void Gamealloc_FreeAll(GameAlloc* heap);
void Gamealloc_Init(GameAlloc* iParm1);
void Game_Nop80173534(GameState* gameState);
void GameState_Draw(GameState* gameState, GraphicsContext* gCtxt);
void GameState_SetFrameBuffer(GraphicsContext* gCtxt);
void func_801736DC(GraphicsContext* gCtxt);
void Game_UpdateInput(GameState* gameState);
void Game_Update(GameState* gameState);
void Game_IncrementFrameCount(GameState* gameState);
void GameState_InitArena(GameState* gameState, size_t size);
void GameState_Realloc(GameState* gameState, size_t size);
void GameState_Init(GameState* gameState, GameStateFunc gameStateInit, GraphicsContext* gfxCtx);
void GameState_Destroy(GameState* gameState);
GameStateFunc GameState_GetNextStateInit(GameState* gameState);
size_t Game_GetNextStateSize(GameState* gameState);
u32 GameState_IsRunning(GameState* gameState);
s32 GameState_GetArenaSize(GameState* gameState);
s32 func_80173B48(GameState* gameState);
void GameAlloc_Log(GameAlloc* heap);
void* GameAlloc_Malloc(GameAlloc* heap, size_t size);
void GameAlloc_Free(GameAlloc* heap, void* ptr);
void GameAlloc_Cleanup(GameAlloc* heap);
void GameAlloc_Init(GameAlloc* iParm1);
// void Graph_FaultClient(void);
void Graph_DlAlloc(TwoHeadGfxArena* dl, void* memoryBlock, u32 size);
void Graph_DlAlloc(TwoHeadGfxArena* dl, void* memoryBlock, size_t size);
void Graph_InitTHGA(GraphicsContext* gfxCtx);
GameStateOverlay* Graph_GetNextGameState(GameState* gamestate);
GameStateOverlay* Graph_GetNextGameState(GameState* gameState);
void* Graph_FaultAddrConvFunc(void* addr);
void Graph_Init(GraphicsContext* gfxCtx);
// void Graph_Destroy(void);
void Graph_Render(GraphicsContext* gfxCtx, GameState* gamestate);
void Graph_FrameSetup(GameState* gamestate);
void Graph_RenderFrame(GraphicsContext* gfxCtx, GameState* gamestate);
void Graph_DoFrame(GraphicsContext* gfxCtx, GameState* gamestate);
void Graph_Render(GraphicsContext* gfxCtx, GameState* gameState);
void Graph_FrameSetup(GameState* gameState);
void Graph_RenderFrame(GraphicsContext* gfxCtx, GameState* gameState);
void Graph_DoFrame(GraphicsContext* gfxCtx, GameState* gameState);
void Graph_ThreadEntry(void* arg);
Gfx* Graph_GfxPlusOne(Gfx* gfx);
Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst);
void* Graph_DlistAlloc(Gfx** gfx, u32 size);
void func_80174AA0(ListAlloc* alloc);
// void func_80174AB4(void);
// void func_80174B20(void);
void func_80174BA0(ListAlloc* alloc);
void* Graph_DlistAlloc(Gfx** gfx, size_t size);
ListAlloc* ListAlloc_Init(ListAlloc* this);
// void ListAlloc_Alloc(void);
// void ListAlloc_Free(void);
void ListAlloc_FreeAll(ListAlloc* this);
void Main(void* arg);
u32 Padmgr_GetControllerBitmask(void);
// void func_80174F24(void);
@@ -3213,7 +3232,7 @@ void func_80175E68(Input* input, s32 param_2);
void Padmgr_GetInput(Input* input, s32 param_2);
void Padmgr_GetInput2(Input* input, s32 param_2);
void Padmgr_ThreadEntry(PadMgr* padmgr);
void Padmgr_Start(OSMesgQueue* siEventCallbackQueue, IrqMgr* irqmgr, OSId threadId, OSPri threadPri, void* stack);
void PadMgr_Init(OSMesgQueue* siEventCallbackQueue, IrqMgr* irqmgr, OSId threadId, OSPri threadPri, void* stack);
void Sched_SwapFramebuffer(CfbInfo* cfbInfo);
void Sched_RetraceUpdateFramebuffer(SchedContext* sched, CfbInfo* cfbInfo);
void Sched_HandleReset(SchedContext* sched);
@@ -3239,9 +3258,9 @@ void Sched_Init(SchedContext* sched, void* stack, OSPri pri, UNK_TYPE arg3, UNK_
// void func_80177390(void);
void func_801773A0(void* arg0);
void func_801773C4(void* arg0);
void SpeedMeter_DrawTimeEntries(void* displayList, GraphicsContext* gCtx);
// void func_80177A84(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
// void func_80177AC8(void);
void SpeedMeter_DrawTimeEntries(void* displayList, GraphicsContext* gfxCtx);
// void func_80177A84(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
//void func_80177AC8(void);
void SpeedMeter_DrawAllocEntries(void* displayList, GraphicsContext* gfxCtx, GameState* gameState);
void func_801780F0(Mtx* param_1, f32 param_2, f32 param_3, f32 param_4, f32 param_5, f32 param_6, f32 param_7);
// void func_801781EC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
@@ -3375,46 +3394,48 @@ s16 Math_Atan2S(f32 opposite, f32 adjacent);
f32 Math_Atan2F(f32 opposite, f32 adjacent);
s16 Math_FAtan2F(f32 adjacent, f32 opposite);
f32 Math_Acot2F(f32 adjacent, f32 opposite);
void SysMatrix_StateAlloc(GameState* gamestate);
void SysMatrix_StatePush(void);
void SysMatrix_StatePop(void);
void SysMatrix_CopyCurrentState(MtxF* matrix);
void SysMatrix_SetCurrentState(MtxF* matrix);
MtxF* SysMatrix_GetCurrentState(void);
void SysMatrix_InsertMatrix(MtxF* matrix, s32 appendToState);
void SysMatrix_InsertTranslation(f32 x, f32 y, f32 z, s32 appendToState);
void Matrix_StateAlloc(GameState* gameState);
void Matrix_StatePush(void);
void Matrix_StatePop(void);
void Matrix_CopyCurrentState(MtxF* matrix);
void Matrix_SetCurrentState(MtxF* matrix);
MtxF* Matrix_GetCurrentState(void);
void Matrix_InsertMatrix(MtxF* matrix, s32 appendToState);
void Matrix_InsertTranslation(f32 x, f32 y, f32 z, s32 appendToState);
void Matrix_Scale(f32 xScale, f32 yScale, f32 zScale, s32 appendToState);
void SysMatrix_InsertXRotation_s(s16 rotation, s32 appendToState);
void SysMatrix_InsertXRotation_f(f32 rotation, s32 appendToState);
void SysMatrix_RotateStateAroundXAxis(f32 rotation);
void SysMatrix_SetStateXRotation(f32 rotation);
void Matrix_InsertXRotation_s(s16 rotation, s32 appendToState);
void Matrix_InsertXRotation_f(f32 rotation, s32 appendToState);
void Matrix_RotateStateAroundXAxis(f32 rotation);
void Matrix_SetStateXRotation(f32 rotation);
void Matrix_RotateY(s16 rotation, s32 appendToState);
void SysMatrix_InsertYRotation_f(f32 rotation, s32 appendToState);
void SysMatrix_InsertZRotation_s(s16 rotation, s32 appendToState);
void SysMatrix_InsertZRotation_f(f32 rotation, s32 appendToState);
void SysMatrix_InsertRotation(s16 xRotation, s16 yRotation, s16 zRotation, s32 appendToState);
void SysMatrix_RotateAndTranslateState(Vec3f* translation, Vec3s* rotation);
void SysMatrix_SetStateRotationAndTranslation(f32 x, f32 y, f32 z, Vec3s* rotation);
RSPMatrix* SysMatrix_ToRSPMatrix(MtxF* src, RSPMatrix* dst);
RSPMatrix* SysMatrix_GetStateAsRSPMatrix(RSPMatrix* matrix);
void Matrix_InsertYRotation_f(f32 rotation, s32 appendToState);
void Matrix_InsertZRotation_s(s16 rotation, s32 appendToState);
void Matrix_InsertZRotation_f(f32 rotation, s32 appendToState);
void Matrix_InsertRotation(s16 xRotation, s16 yRotation, s16 zRotation, s32 appendToState);
void Matrix_JointPosition(Vec3f* position, Vec3s* rotation);
void Matrix_RotateAndTranslateState(Vec3f* translation, Vec3s* rotation);
void Matrix_SetStateRotationAndTranslation(f32 x, f32 y, f32 z, Vec3s* rotation);
RSPMatrix* Matrix_ToRSPMatrix(MtxF* src, RSPMatrix* dst);
Mtx* Matrix_ToMtx(Mtx* dest);
RSPMatrix* Matrix_GetStateAsRSPMatrix(RSPMatrix* matrix);
Mtx* Matrix_NewMtx(GraphicsContext* gfxCtx);
RSPMatrix* SysMatrix_AppendStateToPolyOpaDisp(GraphicsContext* gfxCtx);
void SysMatrix_AppendToPolyOpaDisp(MtxF* mtx, GraphicsContext* gfxCtx);
void SysMatrix_MultiplyVector3fByState(Vec3f* src, Vec3f* dst);
void SysMatrix_GetStateTranslation(Vec3f* dst);
void SysMatrix_GetStateTranslationAndScaledX(f32 scale, Vec3f* dst);
void SysMatrix_GetStateTranslationAndScaledY(f32 scale, Vec3f* dst);
void SysMatrix_GetStateTranslationAndScaledZ(f32 scale, Vec3f* dst);
void SysMatrix_MultiplyVector3fXZByCurrentState(Vec3f* src, Vec3f* dst);
RSPMatrix* Matrix_AppendStateToPolyOpaDisp(GraphicsContext* gfxCtx);
void Matrix_AppendToPolyOpaDisp(MtxF* mtx, GraphicsContext* gfxCtx);
void Matrix_MultiplyVector3fByState(Vec3f* src, Vec3f* dst);
void Matrix_GetStateTranslation(Vec3f* dst);
void Matrix_GetStateTranslationAndScaledX(f32 scale, Vec3f* dst);
void Matrix_GetStateTranslationAndScaledY(f32 scale, Vec3f* dst);
void Matrix_GetStateTranslationAndScaledZ(f32 scale, Vec3f* dst);
void Matrix_MultiplyVector3fXZByCurrentState(Vec3f* src, Vec3f* dst);
void Matrix_MtxFCopy(MtxF* dst, MtxF* src);
void SysMatrix_FromRSPMatrix(RSPMatrix* src, MtxF* dst);
void SysMatrix_MultiplyVector3fByMatrix(Vec3f* src, Vec3f* dst, MtxF* matrix);
void SysMatrix_TransposeXYZ(MtxF* matrix);
void SysMatrix_NormalizeXYZ(MtxF* matrix);
void Matrix_FromRSPMatrix(Mtx* src, MtxF* dst);
void Matrix_MultiplyVector3fByMatrix(Vec3f* src, Vec3f* dst, MtxF* matrix);
void Matrix_TransposeXYZ(MtxF* matrix);
void Matrix_NormalizeXYZ(MtxF* matrix);
void func_8018219C(MtxF* pfParm1, Vec3s* psParm2, s32 iParm3);
// void func_801822C4(void);
void SysMatrix_InsertRotationAroundUnitVector_f(f32 rotation, Vec3f* vector, s32 appendToState);
void SysMatrix_InsertRotationAroundUnitVector_s(s16 rotation, Vec3f* vector, s32 appendToState);
void Matrix_InsertRotationAroundUnitVector_f(f32 rotation, Vec3f* vector, s32 appendToState);
void Matrix_InsertRotationAroundUnitVector_s(s16 rotation, Vec3f* vector, s32 appendToState);
// void func_80182C90(void);
// void func_80182CA0(void);
// void func_80182CBC(void);
include/io/controller.h
+2 -1
View File
@@ -139,7 +139,8 @@ typedef struct {
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 cmd;
/* 0x04 */ u16 address;
/* 0x04 */ u8 hi;
/* 0x05 */ u8 lo;
/* 0x06 */ u8 data[32];
/* 0x26 */ u8 datacrc;
} __OSContRamReadFormat;
include/os.h
+4 -3
View File
@@ -1,6 +1,7 @@
#ifndef _OS_H_
#define _OS_H_
#include "stdlib.h"
#include "ultra64/thread.h"
#include "ultra64/message.h"
@@ -65,7 +66,7 @@ typedef struct {
/* 0x00 */ OSIoMesgHdr hdr;
/* 0x08 */ void* dramAddr;
/* 0x0C */ u32 devAddr;
/* 0x10 */ u32 size;
/* 0x10 */ size_t size;
/* 0x14 */ OSPiHandle* piHandle;
} OSIoMesg; // size = 0x88
@@ -76,8 +77,8 @@ typedef struct {
/* 0x08 */ OSMesgQueue* cmdQueue;
/* 0x0C */ OSMesgQueue* evtQueue;
/* 0x10 */ OSMesgQueue* acsQueue;
/* 0x14 */ s32 (*piDmaCallback)(s32, u32, void*, u32);
/* 0x18 */ s32 (*epiDmaCallback)(OSPiHandle*, s32, u32, void*, u32);
/* 0x14 */ s32 (*piDmaCallback)(s32, u32, void*, size_t);
/* 0x18 */ s32 (*epiDmaCallback)(OSPiHandle*, s32, u32, void*, size_t);
} OSDevMgr; // size = 0x1C
include/os_internal.h
+10
View File
@@ -6,4 +6,14 @@ typedef struct {
/* 0x04 */ OSMesg msg;
} __osHwInt; // size = 0x08
typedef struct {
/* 0x00 */ u32 initialized;
/* 0x04 */ OSThread* mgrThread;
/* 0x08 */ OSMesgQueue* cmdQueue;
/* 0x0C */ OSMesgQueue* eventQueue;
/* 0x10 */ OSMesgQueue* accessQueue;
/* 0x14 */ s32 (*piDmaCallback)(s32, u32, void*, size_t);
/* 0x18 */ s32 (*epiDmaCallback)(OSPiHandle*, s32, u32, void*, size_t);
} OSMgrArgs; // size = 0x1C
#endif
include/stdlib.h
+1 -1
View File
@@ -18,7 +18,7 @@ typedef struct {
/* 0x8 */ long long rem;
} lldiv_t;
typedef unsigned int size_t;
typedef unsigned long size_t;
typedef int ssize_t;
include/string.h
-7
View File
@@ -1,7 +0,0 @@
#ifndef _STRING_H_
#define _STRING_H_
#define NULL 0
typedef unsigned int size_t;
#endif
include/variables.h
+27 -36
View File
@@ -30,8 +30,8 @@ extern vs32 gIrqMgrResetStatus;
extern volatile OSTime sIrqMgrResetTime;
extern volatile OSTime sIrqMgrRetraceTime;
extern s32 sIrqMgrRetraceCount;
extern char* D_80096B80[18];
extern char* sExceptionNames[6];
extern const char* sCpuExceptions[18];
extern const char* sFpuExceptions[6];
extern FaultDrawer* sFaultDrawContext;
extern FaultDrawer sFaultDrawerDefault;
// extern UNK_TYPE4 D_80096C20;
@@ -67,8 +67,8 @@ extern OSPiHandle* __osPiTable;
extern OSPiHandle* __osCurrentHandle[];
extern UNK_TYPE4 __osPiAccessQueueEnabled;
extern OSViMode osViModeNtscHpn1;
// extern UNK_TYPE4 D_80097F00;
// extern UNK_TYPE1 D_80097F04;
extern s32 __osPfsInodeCacheChannel;
extern u8 __osPfsInodeCacheBank;
extern UNK_TYPE4 D_80097F10;
extern char spaces[];
extern char zeroes[];
@@ -207,8 +207,8 @@ extern char D_80098A00[];
extern char D_80098A0C[];
extern char D_80098A1C[];
extern char D_80098A20[34];
extern char D_80098A44[];
extern char D_80098A68[];
extern const char D_80098A44[];
extern const char D_80098A68[];
extern char D_80098A88[53];
extern char D_80098AC0[49];
extern char D_80098AF4[51];
@@ -218,7 +218,7 @@ extern char D_80098B68[];
extern char D_80098B84[];
extern char D_80098BA0[];
extern char D_80098BBC[];
extern char faultThreadName[];
extern const char faultThreadName[];
extern char D_80098BE0[];
extern char D_80098BF8[];
extern char D_80098BFC[];
@@ -230,15 +230,14 @@ extern char D_80098C2C[];
extern char D_80098C34[];
extern char D_80098C38[];
extern char D_80098C40[];
extern u8 sFaultDrawerFont[8][128];
extern char D_80099050[];
extern char D_80099054[];
extern char D_8009905C[];
extern char D_80099064[];
extern char D_80099070[];
extern char D_80099078[];
extern char D_8009907C[];
extern char D_80099080[];
extern const char D_80099078[];
extern const char D_8009907C[];
extern const char D_80099080[];
extern char D_800990B0[];
extern f32 D_800990C0[9];
extern f32 D_800990E4;
@@ -325,10 +324,10 @@ extern FaultDrawer sFaultDrawerStruct;
// extern Arena gSystemArena;
extern u32 sRandFloat;
// extern UNK_TYPE4 sArenaLockMsg;
// extern OSTask tmp_task;
// extern UNK_TYPE1 D_8009CDB0;
// extern OSMesg siAccessBuf[1];
// extern OSMesgQueue __osSiAccessQueue;
extern OSTask tmp_task;
extern OSPifRam osPifBuffers[4];
extern OSMesg siAccessBuf[1];
extern OSMesgQueue __osSiAccessQueue;
extern OSPifRam __osContPifRam;
// extern UNK_TYPE1 D_8009CF0C;
extern u8 __osContLastCmd;
@@ -1673,7 +1672,7 @@ extern UNK_PTR D_801D1540;
// extern f32 sFactorialTbl[13];
extern Vec3f D_801D15B0;
extern Vec3s D_801D15BC;
extern RSPMatrix D_801D1DE0;
extern Mtx D_801D1DE0;
extern MtxF D_801D1E20;
extern UNK_PTR D_801D1E60;
extern UNK_PTR D_801D1E64;
@@ -3263,7 +3262,6 @@ extern TriNorm D_801EF590;
extern TriNorm D_801EF5C8;
extern TriNorm D_801EF600;
extern TriNorm D_801EF638;
// extern UNK_TYPE1 D_801EF66D;
extern SaveContext gSaveContext;
// extern UNK_TYPE2 D_801F3F38;
// extern UNK_TYPE1 D_801F3F3A;
@@ -3344,7 +3342,7 @@ extern s16 D_801F4E7A;
// extern UNK_TYPE1 D_801F4F68;
// extern UNK_TYPE1 D_801F4F6A;
extern LightsBuffer sLightsBuffer;
extern Arena mainHeap;
extern Arena sZeldaArena;
// extern UNK_TYPE1 D_801F5130;
// extern UNK_TYPE1 D_801F5270;
// extern UNK_TYPE1 D_801F528E;
@@ -3368,13 +3366,6 @@ extern Arena mainHeap;
// extern UNK_TYPE1 D_801F59F0;
// extern UNK_TYPE1 D_801F59F4;
// extern UNK_TYPE1 D_801F59F8;
// extern QuakeRequest sQuakeRequest[4];
// extern Quake2Context sQuake2Context;
// extern s32 sMatAnimStep;
// extern u32 sMatAnimFlags;
// extern f32 sMatAnimAlphaRatio;
extern s32 D_801F5AB0;
extern s32 D_801F5AB4;
// extern UNK_TYPE1 D_801F5AC0;
// extern UNK_TYPE1 D_801F69D0;
// extern UNK_TYPE1 D_801F6A10;
@@ -3437,19 +3428,19 @@ extern FaultClient graphFaultClient;
extern Gfx* graphDlEntry;
// extern UNK_TYPE1 D_801F80F8;
extern u64 lastRenderFrameTimestamp;
extern OSMesgQueue siEventCallbackQueue;
extern OSMesg siEventCallbackBuffer[1];
extern OSMesgQueue sSiIntMsgQ;
extern OSMesg sSiIntMsgBuf[1];
extern u32 gSegments[NUM_SEGMENTS];
extern SchedContext gSchedContext;
extern IrqMgrClient mainIrqmgrCallbackNode;
extern OSMesgQueue mainIrqmgrCallbackQueue;
extern OSMesg mainIrqCallbackBuffer[60];
extern OSThread graphOSThread;
extern u8 graphStack[0x1800];
extern u8 schedStack[0x600];
extern u8 audioStack[0x800];
extern u8 padmgrStack[0x500];
extern StackEntry graphStackEntry;
extern IrqMgrClient irqClient;
extern OSMesgQueue irqMgrMsgQ;
extern OSMesg irqMgrMsgBuf[60];
extern OSThread sGraphThread;
extern u8 sGraphStack[6144];
extern u8 schedStack[1536];
extern u8 audioStack[2048];
extern u8 padmgrStack[1280];
extern StackEntry sGraphStackInfo;
extern StackEntry schedStackEntry;
extern StackEntry audioStackEntry;
extern StackEntry padmgrStackEntry;
include/z64.h
+27 -26
View File
@@ -308,7 +308,7 @@ typedef struct GraphicsContext {
/* 0x1B4 */ Gfx* unk1B4;
/* 0x1B8 */ TwoHeadGfxArena unk1B8;
/* 0x1C8 */ UNK_TYPE1 pad1C8[0xAC];
/* 0x274 */ OSViMode* unk274;
/* 0x274 */ OSViMode* viMode;
/* 0x278 */ void* zbuffer;
/* 0x27C */ UNK_TYPE1 pad27C[0x1C];
/* 0x298 */ TwoHeadGfxArena overlay;
@@ -410,13 +410,13 @@ typedef struct {
/* 0xC */ s32 rightX;
} Viewport; // size = 0x10
typedef void*(*fault_address_converter_func)(void* addr, void* arg);
typedef void*(*FaultAddrConvFunc)(void* addr, void* arg);
typedef void(*fault_client_func)(void* arg1, void* arg2);
typedef void(*osCreateThread_func)(void*);
typedef void* (*PrintCallback)(void*, const char*, u32);
typedef void* (*PrintCallback)(void*, const char*, size_t);
typedef enum {
SLOWLY_CALLBACK_NO_ARGS,
@@ -991,7 +991,7 @@ typedef struct {
typedef struct ArenaNode_t {
/* 0x0 */ s16 magic; // Should always be 0x7373
/* 0x2 */ s16 isFree;
/* 0x4 */ u32 size;
/* 0x4 */ size_t size;
/* 0x8 */ struct ArenaNode_t* next;
/* 0xC */ struct ArenaNode_t* prev;
} ArenaNode; // size = 0x10
@@ -1009,7 +1009,7 @@ typedef struct FaultAddrConvClient FaultAddrConvClient;
struct FaultAddrConvClient {
/* 0x0 */ FaultAddrConvClient* next;
/* 0x4 */ fault_address_converter_func callback;
/* 0x4 */ FaultAddrConvFunc callback;
/* 0x8 */ void* param;
}; // size = 0xC
@@ -1044,46 +1044,47 @@ typedef struct FireObj FireObj;
typedef struct FireObjLight FireObjLight;
typedef struct GameAlloc GameAlloc;
typedef struct GameAllocNode {
/* 0x0 */ struct GameAllocNode* next;
/* 0x4 */ struct GameAllocNode* prev;
/* 0x8 */ size_t size;
/* 0xC */ u32 unk_0C;
} GameAllocEntry; // size = 0x10
typedef struct PreNMIContext PreNMIContext;
typedef struct GameAllocNode GameAllocNode;
struct GameAllocNode {
/* 0x0 */ GameAllocNode* next;
/* 0x4 */ GameAllocNode* prev;
/* 0x8 */ u32 size;
/* 0xC */ UNK_TYPE1 padC[0x4];
}; // size = 0x10
struct GameAlloc {
/* 0x00 */ GameAllocNode base;
/* 0x10 */ GameAllocNode* head;
}; // size = 0x14
typedef struct GameAlloc {
/* 0x00 */ GameAllocEntry base;
/* 0x10 */ GameAllocEntry* head;
} GameAlloc; // size = 0x14
struct GameState {
/* 0x00 */ GraphicsContext* gfxCtx;
/* 0x04 */ GameStateFunc main;
/* 0x08 */ GameStateFunc destroy;
/* 0x0C */ GameStateFunc nextGameStateInit;
/* 0x10 */ u32 nextGameStateSize;
/* 0x10 */ size_t nextGameStateSize;
/* 0x14 */ Input input[4];
/* 0x74 */ TwoHeadArena heap;
/* 0x84 */ GameAlloc alloc;
/* 0x98 */ UNK_TYPE1 pad98[0x3];
/* 0x9B */ u8 running; // If 0, switch to next game state
/* 0x9C */ u32 frames;
/* 0xA0 */ UNK_TYPE1 padA0[0x2];
/* 0xA0 */ u8 padA0[0x2];
/* 0xA2 */ u8 framerateDivisor; // game speed?
/* 0xA3 */ UNK_TYPE1 unkA3;
}; // size = 0xA4
struct PreNMIContext {
typedef struct PreNMIContext {
/* 0x00 */ GameState state;
/* 0xA4 */ u32 timer;
/* 0xA8 */ UNK_TYPE4 unkA8;
}; // size = 0xAC
} PreNMIContext; // size = 0xAC
typedef struct {
/* 0x00 */ u32 resetting;
/* 0x04 */ u32 resetCount;
/* 0x08 */ OSTime duration;
/* 0x10 */ OSTime resetTime;
} PreNmiBuff; // size = 0x18 (actually osAppNmiBuffer is 0x40 bytes large but the rest is unused)
typedef struct GlobalContext GlobalContext;
@@ -1266,7 +1267,7 @@ typedef struct {
/* 0x024 */ UNK_TYPE4 unk24;
/* 0x028 */ OSMesg lockMesg[1];
/* 0x02C */ OSMesg interrupts[8];
/* 0x04C */ OSMesgQueue siEventCallbackQueue;
/* 0x04C */ OSMesgQueue sSiIntMsgQ;
/* 0x064 */ OSMesgQueue lock;
/* 0x07C */ OSMesgQueue irqmgrCallbackQueue;
/* 0x094 */ IrqMgrClient irqmgrCallbackQueueNode;
include/z64actor.h
+9 -5
View File
@@ -141,7 +141,7 @@ typedef struct {
/* 0x10 */ f32 shadowScale; // Changes the size of the shadow
/* 0x14 */ u8 shadowAlpha; // Default is 255
/* 0x15 */ u8 feetFloorFlags; // Set if the actor's foot is clipped under the floor. & 1 is right foot, & 2 is left
/* 0x18 */ Vec3f feetPos[2]; // Update by using `Actor_SetFeetPos` in PostLimbDraw
/* 0x18 */ Vec3f feetPos[2]; // Update by using `Actor_SetFeetPos` in PostLimbDrawOpa
} ActorShape; // size = 0x30
typedef struct Actor {
@@ -289,12 +289,16 @@ typedef struct EnItem00 {
/* 0x1A4 */ s8 unk1A4;
} EnItem00; // size = 0x1A8
typedef struct {
/* 0x000 */ Actor base;
/* 0x144 */ ActorFunc update;
struct EnAObj;
typedef void (*EnAObjActionFunc)(struct EnAObj*, struct GlobalContext*);
typedef struct EnAObj {
/* 0x000 */ Actor actor;
/* 0x144 */ EnAObjActionFunc actionFunc;
/* 0x148 */ ColliderCylinder collision;
/* 0x194 */ UNK_TYPE1 pad194[0x14];
} ActorEnAObj; // size = 0x1A8
} EnAObj; // size = 0x1A8
typedef enum {
/* 0x00 */ ACTORCAT_SWITCH,
include/z64animation.h
+131 -111
View File
@@ -6,196 +6,216 @@
#include "z64dma.h"
#include "z64math.h"
struct GlobalContext;
struct Actor;
struct SkelAnime;
#define LINK_ANIMETION_OFFSET(addr, offset) \
(SEGMENT_ROM_START(link_animetion) + ((u32)addr & 0xFFFFFF) + ((u32)offset))
#define LIMB_DONE 0xFF
#define ANIMATION_ENTRY_MAX 50
#define ANIM_FLAG_UPDATEXZ 0x02
#define ANIM_FLAG_UPDATEY 0x10
#define ANIM_FLAG_UPDATEY (1 << 1)
#define ANIM_FLAG_NOMOVE (1 << 4)
struct GlobalContext;
struct Actor;
typedef struct SkelAnime SkelAnime;
typedef enum {
/* 0 */ ANIMMODE_LOOP,
/* 1 */ ANIMMODE_LOOP_INTERP,
/* 2 */ ANIMMODE_ONCE,
/* 3 */ ANIMMODE_ONCE_INTERP,
/* 4 */ ANIMMODE_LOOP_PARTIAL,
/* 5 */ ANIMMODE_LOOP_PARTIAL_INTERP
} AnimationModes;
typedef enum {
/* -1 */ ANIMTAPER_DECEL = -1,
/* 0 */ ANIMTAPER_NONE,
/* 1 */ ANIMTAPER_ACCEL
} AnimationTapers;
typedef struct {
/* 0x000 */ Vec3s translation; // Translation relative to parent limb. root limb is a tranlation for entire model.
/* 0x006 */ u8 firstChildIndex; // The first child's index into the limb table.
/* 0x007 */ u8 nextLimbIndex; // The parent limb's next limb index into the limb table.
/* 0x008 */ Gfx* displayLists[1]; // Display lists for the limb. Index 0 is the normal display list, index 1 is the
// far model display list.
} StandardLimb; // Size = 0xC
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child; // The first child's index into the limb table.
/* 0x07 */ u8 sibling; // The parent limb's next limb index into the limb table.
/* 0x08 */ Gfx* dList; // Display lists for the limb. Index 0 is the normal display list, index 1 is the
// far model display list.
} StandardLimb; // size = 0xC
// Model has limbs with only rigid meshes
typedef struct {
/* 0x000 */ void** skeletonSeg; // Segment address of SkelLimbIndex.
/* 0x004 */ u8 limbCount; // Number of limbs in the model.
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ Gfx* dLists[2]; // Near and far
} LodLimb; // size = 0x10
// Model has limbs with only rigid meshes
typedef struct {
/* 0x00 */ void** segment;
/* 0x04 */ u8 limbCount;
} SkeletonHeader; // size = 0x8
// Model has limbs with flexible meshes
typedef struct {
/* 0x000 */ SkeletonHeader sh;
/* 0x008 */ u8 dListCount; // Number of display lists in the model.
/* 0x00 */ SkeletonHeader sh;
/* 0x08 */ u8 dListCount;
} FlexSkeletonHeader; // size = 0xC
typedef s16 AnimationRotationValue;
// Index into the frame data table.
typedef struct {
/* 0x000 */ u16 x;
/* 0x002 */ u16 y;
/* 0x004 */ u16 z;
/* 0x00 */ u16 x;
/* 0x02 */ u16 y;
/* 0x04 */ u16 z;
} JointIndex; // size = 0x06
typedef struct {
/* 0x000 */ s16 frameCount;
/* 0x002 */ s16 unk02;
} AnimationHeaderCommon; // size = 0x4
/* 0x00 */ s16 frameCount;
} AnimationHeaderCommon;
typedef struct {
/* 0x00 */ AnimationHeaderCommon common;
/* 0x04 */ s16* frameData; // referenced as tbl
/* 0x08 */ JointIndex* jointIndices; // referenced as ref_tbl
/* 0x0C */ u16 staticIndexMax;
/* 0x000 */ AnimationHeaderCommon common;
/* 0x004 */ s16* frameData; // referenced as tbl
/* 0x008 */ JointIndex* jointIndices; // referenced as ref_tbl
/* 0x00C */ u16 staticIndexMax;
} AnimationHeader; // size = 0x10
typedef struct {
/* 0x00 */ s16 xMax;
/* 0x02 */ s16 x;
/* 0x04 */ s16 yMax;
/* 0x06 */ s16 y;
/* 0x08 */ s16 zMax;
/* 0x10 */ s16 z;
} JointKey; // size = 0x12
typedef struct {
/* 0x00 */ s16 frameCount;
/* 0x02 */ s16 limbCount;
/* 0x04 */ s16* frameData;
/* 0x08 */ JointKey* jointKey;
} LegacyAnimationHeader; // size = 0xC
typedef enum {
ANIMATION_LINKANIMETION,
ANIMATION_TYPE1,
ANIMATION_TYPE2,
ANIMATION_TYPE3,
ANIMATION_TYPE4,
ANIMATION_TYPE5
ANIMENTRY_COPYALL,
ANIMENTRY_INTERP,
ANIMENTRY_COPYTRUE,
ANIMENTRY_COPYFALSE,
ANIMENTRY_MOVEACTOR
} AnimationType;
typedef struct {
/* 0x000 */ DmaRequest req;
/* 0x020 */ OSMesgQueue msgQueue;
/* 0x038 */ OSMesg msg;
} AnimationEntryType0; // size = 0x3C
} AnimEntryLoadFrame; // size = 0x3C
typedef struct {
/* 0x000 */ u8 unk00;
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
} AnimationEntryType1; // size = 0xC
} AnimEntryCopyAll; // size = 0xC
typedef struct {
/* 0x000 */ u8 unk00;
/* 0x001 */ u8 limbCount;
/* 0x004 */ Vec3s* unk04;
/* 0x008 */ Vec3s* unk08;
/* 0x00C */ f32 unk0C;
} AnimationEntryType2; // size = 0x10
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* base;
/* 0x008 */ Vec3s* mod;
/* 0x00C */ f32 weight;
} AnimEntryInterp; // size = 0x10
typedef struct {
/* 0x000 */ u8 unk00;
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
/* 0x00C */ u8* index;
} AnimationEntryType3; // size = 0x10
/* 0x00C */ u8* copyFlag;
} AnimEntryCopyTrue; // size = 0x10
typedef struct {
/* 0x000 */ u8 unk00;
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x002 */ char unk02[0x2];
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
/* 0x00C */ u8* index;
} AnimationEntryType4; // size = 0x10
/* 0x00C */ u8* copyFlag;
} AnimEntryCopyFalse; // size = 0x10
typedef struct {
/* 0x000 */ struct Actor* actor;
/* 0x004 */ SkelAnime* skelAnime;
/* 0x004 */ struct SkelAnime* skelAnime;
/* 0x008 */ f32 unk08;
} AnimationEntryType5; // size = 0xC
typedef struct {
/* 0x000 */ u8 raw[0x3C];
} AnimationEntryRaw; // size = 0x3C
} AnimEntryMoveActor; // size = 0xC
typedef union {
AnimationEntryRaw raw;
AnimationEntryType0 type0;
AnimationEntryType1 type1;
AnimationEntryType2 type2;
AnimationEntryType3 type3;
AnimationEntryType4 type4;
AnimationEntryType5 type5;
} AnimationEntryType; // size = 0x3C
AnimEntryLoadFrame load;
AnimEntryCopyAll copy;
AnimEntryInterp interp;
AnimEntryCopyTrue copy1;
AnimEntryCopyFalse copy0;
AnimEntryMoveActor move;
} AnimationEntryData; // size = 0x3C
typedef struct {
/* 0x000 */ u8 type;
/* 0x001 */ u8 unk01;
/* 0x004 */ AnimationEntryType types;
/* 0x004 */ AnimationEntryData data;
} AnimationEntry; // size = 0x40
typedef struct AnimationContext {
/* 0x000 */ s16 animationCount;
/* 0x002 */ char unk02[2];
/* 0x004 */ AnimationEntry entries[ANIMATION_ENTRY_MAX];
} AnimationContext; // size = 0xC84
typedef struct {
/* 0x00 */ AnimationHeaderCommon common;
/* 0x04 */ u32 segment;
/* 0x000 */ AnimationHeaderCommon common;
/* 0x004 */ u32 segment;
} LinkAnimationHeader; // size = 0x8
struct SkelAnime {
/* 0x00 */ u8 limbCount; // joint_Num
/* modes 0 and 1 repeat the animation indefinitely
* modes 2 and 3 play the animaton once then stop
* modes >= 4 play the animation once, and always start at frame 0.
*/
/* 0x01 */ u8 mode;
/* 0x02 */ u8 dListCount;
/* 0x03 */ s8 unk03;
typedef struct SkelAnime {
/* 0x00 */ u8 limbCount; // Number of limbs in the skeleton
/* 0x01 */ u8 mode; // 0: loop, 2: play once, 4: partial loop. +1 to interpolate between frames.
/* 0x02 */ u8 dListCount; // Number of display lists in a flexible skeleton
/* 0x03 */ s8 taper; // Tapering to use when morphing between animations. Only used by Door_Warp1.
/* 0x04 */ void** skeleton; // An array of pointers to limbs. Can be StandardLimb, LodLimb, or SkinLimb.
/* 0x08 */
union {
AnimationHeader* animCurrentSeg;
LinkAnimationHeader* linkAnimetionSeg;
AnimationHeaderCommon* genericSeg;
};
/* 0x0C */ f32 initialFrame;
/* 0x10 */ f32 animFrameCount;
/* 0x14 */ f32 totalFrames;
/* 0x18 */ f32 animCurrentFrame;
/* 0x1C */ f32 animPlaybackSpeed;
/* 0x20 */ Vec3s* limbDrawTbl; // now_joint
/* 0x24 */ Vec3s* transitionDrawTbl; // morf_joint
/* 0x28 */ f32 transCurrentFrame;
/* 0x2C */ f32 transitionStep;
/* 0x30 */ s32 (*animUpdate)();
/* 0x34 */ s8 initFlags;
/* 0x35 */ u8 flags;
/* 0x36 */ s16 prevFrameRot;
/* 0x38 */ Vec3s prevFramePos;
/* 0x3E */ Vec3s unk3E;
}; // size = 0x44
/* 0x08 */ void* animation; // Can be an AnimationHeader or LinkAnimationHeader.
/* 0x0C */ f32 startFrame; // In mode 4, start of partial loop.
/* 0x10 */ f32 endFrame; // In mode 2, Update returns true when curFrame is equal to this. In mode 4, end of partial loop.
/* 0x14 */ f32 animLength; // Total number of frames in the current animation's file.
/* 0x18 */ f32 curFrame; // Current frame in the animation
/* 0x1C */ f32 playSpeed; // Multiplied by R_UPDATE_RATE / 3 to get the animation's frame rate.
/* 0x20 */ Vec3s* jointTable; // Current translation of model and rotations of all limbs
/* 0x24 */ Vec3s* morphTable; // Table of values used to morph between animations
/* 0x28 */ f32 morphWeight; // Weight of the current animation morph as a fraction in [0,1]
/* 0x2C */ f32 morphRate; // Reciprocal of the number of frames in the morph
/* 0x30 */ s32 (*update)(); // Can be Loop, Partial loop, Play once, Morph, or Tapered morph. Link only has Loop, Play once, and Morph
/* 0x34 */ s8 initFlags; // Flags used when initializing Link's skeleton
/* 0x35 */ u8 moveFlags; // Flags used for animations that move the actor in worldspace.
/* 0x36 */ s16 prevRot; // Previous rotation in worldspace.
/* 0x38 */ Vec3s prevTransl; // Previous modelspace translation.
/* 0x3E */ Vec3s baseTransl; // Base modelspace translation.
} SkelAnime; // size = 0x44
typedef s32 (*OverrideLimbDraw)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
typedef s32 (*OverrideLimbDrawOpa)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
struct Actor* actor);
typedef void (*PostLimbDrawOpa)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot,
struct Actor* actor);
typedef s32 (*OverrideLimbDraw)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
struct Actor* actor, Gfx** gfx);
typedef void (*PostLimbDraw)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot,
struct Actor* actor);
struct Actor* actor, Gfx** gfx);
typedef s32 (*OverrideLimbDraw2)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
struct Actor* actor, Gfx** gfx);
typedef s32 (*OverrideLimbDrawFlex)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
struct Actor* actor);
typedef void (*PostLimbDraw2)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot,
struct Actor* actor, Gfx** gfx);
typedef s32 (*OverrideLimbDrawSV)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
struct Actor* actor);
typedef void (*PostLimbDrawSV)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList1, Gfx** dList2, Vec3s* rot,
struct Actor* actor);
typedef void (*PostLimbDrawFlex)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList1, Gfx** dList2, Vec3s* rot,
struct Actor* actor);
typedef void (*UnkActorDraw)(struct GlobalContext* globalCtx, s32 limbIndex, struct Actor* actor);
typedef void (*AnimationEntryCallback)(struct GlobalContext*, AnimationEntryType*);
typedef void (*AnimationEntryCallback)(struct GlobalContext*, AnimationEntryData*);
extern u32 link_animetion_segment;
include/z64effect.h
+27 -6
View File
@@ -274,16 +274,37 @@ typedef struct {
/* 0x8 */ s32 size;
} EffectSsInfo; // size = 0xC
typedef struct {
/* 0x0 */ EffectSs* data_table; // Name from debug assert
/* 0x4 */ s32 searchIndex;
/* 0x8 */ s32 size;
} EffectTableInfo; // size = 0xC
typedef struct {
/* 0x0 */ UNK_TYPE4 unk0;
/* 0x4 */ EffectSsInitFunc init;
} ParticleOverlayInfo; // size = 0x8
typedef struct {
/* 0x00 */ u32 vromStart;
/* 0x04 */ u32 vromEnd;
/* 0x08 */ void* vramStart;
/* 0x0C */ void* vramEnd;
/* 0x10 */ void* loadedRamAddr;
/* 0x14 */ ParticleOverlayInfo* overlayInfo;
/* 0x18 */ u32 unk18; // Always 0x01000000?
} ParticleOverlay; // size = 0x1C
typedef enum {
/* 0x00 */ EFFECT_SS_DUST,
/* 0x01 */ EFFECT_SS_KIRAKIRA,
/* 0x02 */ EFFECT_SS_UNSET_02,
/* 0x02 */ EFFECT_SS_UNSET_02, // Deleted
/* 0x03 */ EFFECT_SS_BOMB2,
/* 0x04 */ EFFECT_SS_BLAST,
/* 0x05 */ EFFECT_SS_G_SPK,
/* 0x06 */ EFFECT_SS_D_FIRE,
/* 0x07 */ EFFECT_SS_BUBBLE,
/* 0x08 */ EFFECT_SS_UNSET_08,
/* 0x08 */ EFFECT_SS_UNSET_08, // Deleted
/* 0x09 */ EFFECT_SS_G_RIPPLE,
/* 0x0A */ EFFECT_SS_G_SPLASH,
/* 0x0B */ EFFECT_SS_UNSET_0B,
@@ -293,8 +314,8 @@ typedef enum {
/* 0x0F */ EFFECT_SS_HAHEN,
/* 0x10 */ EFFECT_SS_STICK,
/* 0x11 */ EFFECT_SS_SIBUKI,
/* 0x12 */ EFFECT_SS_UNSET_12,
/* 0x13 */ EFFECT_SS_UNSET_13,
/* 0x12 */ EFFECT_SS_UNSET_12, // Deleted
/* 0x13 */ EFFECT_SS_UNSET_13, // Deleted
/* 0x14 */ EFFECT_SS_STONE1,
/* 0x15 */ EFFECT_SS_HITMARK,
/* 0x16 */ EFFECT_SS_FHG_FLASH,
@@ -306,11 +327,11 @@ typedef enum {
/* 0x1C */ EFFECT_SS_FIRE_TAIL,
/* 0x1D */ EFFECT_SS_EN_FIRE,
/* 0x1E */ EFFECT_SS_EXTRA,
/* 0x1F */ EFFECT_SS_UNSET_1F,
/* 0x1F */ EFFECT_SS_UNSET_1F, // Deleted
/* 0x20 */ EFFECT_SS_DEAD_DB,
/* 0x21 */ EFFECT_SS_DEAD_DD,
/* 0x22 */ EFFECT_SS_DEAD_DS,
/* 0x23 */ EFFECT_SS_UNSET_23,
/* 0x23 */ EFFECT_SS_UNSET_23, // Deleted
/* 0x24 */ EFFECT_SS_ICE_SMOKE,
/* 0x25 */ EFFECT_EN_ICE_BLOCK,
/* 0x26 */ EFFECT_SS_SBN,
include/z64scene.h
+2 -2
View File
@@ -215,8 +215,8 @@ typedef struct {
} SCmdMinimapChests;
typedef struct {
/* 0x0 */ u32 opaqueDl;
/* 0x4 */ u32 translucentDl;
/* 0x0 */ Gfx* opaqueDl;
/* 0x4 */ Gfx* translucentDl;
} RoomMeshType0Params; // size = 0x8
// Fields TODO