From bbd58ffca67ef2c4ba93100cae3bf091e902c3e9 Mon Sep 17 00:00:00 2001 From: seilweiss <32021834+seilweiss@users.noreply.github.com> Date: Fri, 23 Oct 2020 11:51:46 -0500 Subject: [PATCH 1/2] decomp most of xAnim.cpp --- asm/Core/x/xAnim.s | 39 +- src/Core/x/xAnim.cpp | 860 ++++++++++++++++++++++++++++++++++++++----- src/Core/x/xAnim.h | 148 +++++--- 3 files changed, 898 insertions(+), 149 deletions(-) diff --git a/asm/Core/x/xAnim.s b/asm/Core/x/xAnim.s index a6848a515..d0cd1a2a5 100644 --- a/asm/Core/x/xAnim.s +++ b/asm/Core/x/xAnim.s @@ -554,9 +554,9 @@ xAnimInit__Fv: /* 80005FE0 00002DE0 7C 08 02 A6 */ mflr r0 /* 80005FE4 00002DE4 90 01 00 14 */ stw r0, 0x14(r1) /* 80005FE8 00002DE8 48 0B 8A 0D */ bl iAnimInit__Fv -/* 80005FEC 00002DEC 3C 60 80 2C */ lis r3, lbl_802B89E0@ha +/* 80005FEC 00002DEC 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha /* 80005FF0 00002DF0 38 80 00 00 */ li r4, 0 -/* 80005FF4 00002DF4 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 80005FF4 00002DF4 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 80005FF8 00002DF8 38 A0 00 1C */ li r5, 0x1c /* 80005FFC 00002DFC 4B FF D4 5D */ bl memset /* 80006000 00002E00 80 01 00 14 */ lwz r0, 0x14(r1) @@ -575,9 +575,9 @@ xAnimTempTransitionInit__FUi: /* 80006028 00002E28 1C 9F 00 2C */ mulli r4, r31, 0x2c /* 8000602C 00002E2C 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) /* 80006030 00002E30 48 02 D9 11 */ bl xMemAlloc__FUiUii -/* 80006034 00002E34 3C A0 80 2C */ lis r5, lbl_802B89E0@ha +/* 80006034 00002E34 3C A0 80 2C */ lis r5, sxAnimTempTranPool@ha /* 80006038 00002E38 7C 64 1B 78 */ mr r4, r3 -/* 8000603C 00002E3C 38 65 89 E0 */ addi r3, r5, lbl_802B89E0@l +/* 8000603C 00002E3C 38 65 89 E0 */ addi r3, r5, sxAnimTempTranPool@l /* 80006040 00002E40 7F E9 FB 78 */ mr r9, r31 /* 80006044 00002E44 57 EA F8 7E */ srwi r10, r31, 1 /* 80006048 00002E48 38 A0 00 00 */ li r5, 0 @@ -2912,8 +2912,8 @@ lbl_80007FB0: /* 80008004 00004E04 80 04 00 10 */ lwz r0, 0x10(r4) /* 80008008 00004E08 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 8000800C 00004E0C 41 82 00 10 */ beq lbl_8000801C -/* 80008010 00004E10 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 80008014 00004E14 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 80008010 00004E10 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 80008014 00004E14 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 80008018 00004E18 48 02 BD B9 */ bl xMemPoolFree__FP8xMemPoolPv lbl_8000801C: /* 8000801C 00004E1C 38 00 00 00 */ li r0, 0 @@ -3170,8 +3170,8 @@ lbl_8000836C: /* 800083AC 000051AC 80 04 00 10 */ lwz r0, 0x10(r4) /* 800083B0 000051B0 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 800083B4 000051B4 41 82 00 10 */ beq lbl_800083C4 -/* 800083B8 000051B8 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 800083BC 000051BC 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 800083B8 000051B8 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 800083BC 000051BC 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 800083C0 000051C0 48 02 BA 11 */ bl xMemPoolFree__FP8xMemPoolPv lbl_800083C4: /* 800083C4 000051C4 38 00 00 00 */ li r0, 0 @@ -3185,8 +3185,8 @@ lbl_800083D0: /* 800083E0 000051E0 80 04 00 10 */ lwz r0, 0x10(r4) /* 800083E4 000051E4 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 800083E8 000051E8 41 82 00 10 */ beq lbl_800083F8 -/* 800083EC 000051EC 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 800083F0 000051F0 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 800083EC 000051EC 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 800083F0 000051F0 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 800083F4 000051F4 48 02 B9 DD */ bl xMemPoolFree__FP8xMemPoolPv lbl_800083F8: /* 800083F8 000051F8 38 00 00 00 */ li r0, 0 @@ -3229,8 +3229,8 @@ lbl_80008464: /* 80008478 00005278 80 04 00 10 */ lwz r0, 0x10(r4) /* 8000847C 0000527C 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 80008480 00005280 41 82 00 10 */ beq lbl_80008490 -/* 80008484 00005284 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 80008488 00005288 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 80008484 00005284 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 80008488 00005288 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 8000848C 0000528C 48 02 B9 45 */ bl xMemPoolFree__FP8xMemPoolPv lbl_80008490: /* 80008490 00005290 38 00 00 00 */ li r0, 0 @@ -3266,8 +3266,8 @@ lbl_8000849C: /* 80008504 00005304 80 04 00 10 */ lwz r0, 0x10(r4) /* 80008508 00005308 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 8000850C 0000530C 41 82 00 10 */ beq lbl_8000851C -/* 80008510 00005310 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 80008514 00005314 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 80008510 00005310 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 80008514 00005314 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 80008518 00005318 48 02 B8 B9 */ bl xMemPoolFree__FP8xMemPoolPv lbl_8000851C: /* 8000851C 0000531C 93 9F 00 30 */ stw r28, 0x30(r31) @@ -3700,8 +3700,8 @@ lbl_80008B00: /* 80008B14 00005914 80 04 00 10 */ lwz r0, 0x10(r4) /* 80008B18 00005918 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 80008B1C 0000591C 41 82 00 10 */ beq lbl_80008B2C -/* 80008B20 00005920 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 80008B24 00005924 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 80008B20 00005920 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 80008B24 00005924 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 80008B28 00005928 48 02 B2 A9 */ bl xMemPoolFree__FP8xMemPoolPv lbl_80008B2C: /* 80008B2C 0000592C 38 00 00 00 */ li r0, 0 @@ -3739,8 +3739,8 @@ lbl_80008B98: /* 80008BA4 000059A4 80 04 00 10 */ lwz r0, 0x10(r4) /* 80008BA8 000059A8 54 00 07 BD */ rlwinm. r0, r0, 0, 0x1e, 0x1e /* 80008BAC 000059AC 41 82 00 10 */ beq lbl_80008BBC -/* 80008BB0 000059B0 3C 60 80 2C */ lis r3, lbl_802B89E0@ha -/* 80008BB4 000059B4 38 63 89 E0 */ addi r3, r3, lbl_802B89E0@l +/* 80008BB0 000059B0 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha +/* 80008BB4 000059B4 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l /* 80008BB8 000059B8 48 02 B2 19 */ bl xMemPoolFree__FP8xMemPoolPv lbl_80008BBC: /* 80008BBC 000059BC 93 DF 00 30 */ stw r30, 0x30(r31) @@ -4341,7 +4341,8 @@ lbl_800093F4: .endif .section .bss -lbl_802B89E0: +.global sxAnimTempTranPool +sxAnimTempTranPool: .skip 0x20 .section .sbss diff --git a/src/Core/x/xAnim.cpp b/src/Core/x/xAnim.cpp index 2109cde5f..edbeb875a 100644 --- a/src/Core/x/xAnim.cpp +++ b/src/Core/x/xAnim.cpp @@ -1,54 +1,197 @@ #include "xAnim.h" +#include "../p2/iAnim.h" +#include "xMemMgr.h" +#include "xMath.h" +#include "xString.h" + #include +#include +#include +#include + +extern xMemPool sxAnimTempTranPool; + +static bool _xSingleCompare(char a, char b) +{ + switch (b) + { + case '?': + case '*': + case '+': + { + return true; + } + case '#': + { + return (a >= '0' && a <= '9'); + } + } + + return (a == b); +} + +static bool _xSingleCompare(char ch, const char* str) +{ + while (*str != '\0') + { + if (_xSingleCompare(ch, *str)) + { + return true; + } + + str++; + } + + return false; +} + +static bool _xCharIn(char ch, const char* str) +{ + while (*str != '\0') + { + if (ch == *str) + { + return true; + } + + str++; + } + + return false; +} -// _xSingleCompare(char,char) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xSingleCompare__Fcc") +// _xCheckAnimNameInner(const char*,const char*,int,char*,int*,int*) +#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xCheckAnimNameInner__FPCcPCciPcPiPi") -// _xSingleCompare(char,const char*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xSingleCompare__FcPCc") +bool _xCheckAnimNameInner(const char* name, const char* pattern, int32 patternSize, int8* extra, + int32* nameOut, int32* extraOut); -// _xCharIn(char,const char*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xCharIn__FcPCc") +static bool _xCheckAnimName(const char* name, const char* pattern, int8* extra) +{ + int32 patternSize, nameOut; + bool rc; -// _xCheckAnimNameInner(const char*,const char*,int,char*,int*,int*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xCheckAnimNameInner__FPCcPCciPcPiPi") + *extra = 1; + patternSize = strlen(pattern); -// _xCheckAnimName(const char*,const char*,char*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xCheckAnimName__FPCcPCcPc") + rc = _xCheckAnimNameInner(name, pattern, patternSize, extra, &nameOut, NULL); -// xAnimInit() -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimInit__Fv") + return (rc && name[nameOut] == '\0'); +} -// xAnimTempTransitionInit(unsigned int) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTempTransitionInit__FUi") +void xAnimInit() +{ + iAnimInit(); + memset(&sxAnimTempTranPool, 0, sizeof(xMemPool)); +} -// xatan2(float,float) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xatan2__Fff") +void xAnimTempTransitionInit(uint32 count) +{ + xMemPoolSetup(&sxAnimTempTranPool, xMemAlloc(count * sizeof(xAnimTransition)), 0, 0, NULL, + sizeof(xAnimTransition), count, count / 2); +} -// std::atan2f(float,float) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "atan2f__3stdFff") +// TODO: move to xMathInlines.h +float32 xatan2(float32 y, float32 x) +{ + return xAngleClampFast(std::atan2f(y, x)); +} // CalcRecipBlendMax(unsigned short*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "CalcRecipBlendMax__FPUs") -// StateHasTransition(xAnimState*,xAnimTransition*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "StateHasTransition__FP10xAnimStateP15xAnimTransition") +float CalcRecipBlendMax(uint16*); + +static uint32 StateHasTransition(xAnimState* state, xAnimTransition* tran) +{ + xAnimTransitionList* curr = state->List; + + while (curr) + { + if (curr->T == tran) + { + return TRUE; + } + + curr = curr->Next; + } + + return FALSE; +} + +static uint32 DefaultHasTransition(xAnimState* state, xAnimTransition* tran, uint32* r5) +{ + uint32 r7 = 1; + xAnimTransitionList* curr = state->Default; + + while (curr) + { + if (curr->T == tran) + { + return TRUE; + } + + if (curr->T->Conditional == tran->Conditional && curr->T->UserFlags == tran->UserFlags) + { + r7 = 0; + } + + curr = curr->Next; + } -// DefaultHasTransition(xAnimState*,xAnimTransition*,unsigned int*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "DefaultHasTransition__FP10xAnimStateP15xAnimTransitionPUi") + *r5 += r7; + return FALSE; +} -// DefaultOverride(xAnimState*,xAnimTransition*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "DefaultOverride__FP10xAnimStateP15xAnimTransition") +static uint32 DefaultOverride(xAnimState* state, xAnimTransition* tran) +{ + xAnimTransitionList* list = state->Default; + while (list) + { + if (list->T->Conditional == tran->Conditional && list->T->UserFlags == tran->UserFlags) + { + list->T = tran; + return TRUE; + } + + list = list->Next; + } + + return FALSE; +} + +#if 1 // TransitionTimeInit(xAnimSingle*,xAnimTransition*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "TransitionTimeInit__FP11xAnimSingleP15xAnimTransition") +#else +static void TransitionTimeInit(xAnimSingle* single, xAnimTransition* tran) +{ + if (tran->Flags & 0x20) + { + if ((single->State->Data->FileFlags ^ tran->Dest->Data->FileFlags) & 0x1000) + { + single->Time = tran->Dest->Data->Duration - single->Time; + } + } + else + { + if ((tran->Dest->Flags & 0x100) &&) + } +} +#endif // xAnimFileNewBilinear(void**,const char*,unsigned int,xAnimFile**,unsigned int,unsigned int) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimFileNewBilinear__FPPvPCcUiPP9xAnimFileUiUi") -// xAnimFileNew(void*,const char*,unsigned int,xAnimFile**) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimFileNew__FPvPCcUiPP9xAnimFile") +xAnimFile* xAnimFileNewBilinear(void** rawData, const char* name, uint32 flags, + xAnimFile** linkedList, uint32 numX, uint32 numY); + +xAnimFile* xAnimFileNew(void* rawData, const char* name, uint32 flags, xAnimFile** linkedList) +{ + return xAnimFileNewBilinear(&rawData, name, flags, linkedList, 1, 1); +} // xAnimFileSetTime(xAnimFile*,float,float) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimFileSetTime__FP9xAnimFileff") @@ -56,77 +199,449 @@ // xAnimFileEval(xAnimFile*,float,float*,unsigned int,xVec3*,xQuat*,float*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimFileEval__FP9xAnimFilefPfUiP5xVec3P5xQuatPf") +void xAnimFileEval(xAnimFile* data, float32 time, float32* bilinear, uint32 flags, xVec3* tran, + xQuat* quat, float32*); + // std::floorf(float) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "floorf__3stdFf") -// xAnimStateNewEffect(xAnimState*,unsigned int,float,float,unsigned int (*)(unsigned int, xAnimActiveEffect*, xAnimSingle*, void*),unsigned int) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimStateNewEffect__FP10xAnimStateUiffPFUiP17xAnimActiveEffectP11xAnimSinglePv_UiUi") - -// xAnimTableNew(const char*,xAnimTable**,unsigned int) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableNew__FPCcPP10xAnimTableUi") - -// xAnimDefaultBeforeEnter(xAnimPlay*,xAnimState*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimDefaultBeforeEnter__FP9xAnimPlayP10xAnimState") - +xAnimEffect* xAnimStateNewEffect(xAnimState* state, uint32 flags, float32 startTime, + float32 endTime, xAnimEffectCallback callback, uint32 userDataSize) +{ + xAnimEffect* curr; + xAnimEffect** prev; + xAnimEffect* effect; + + effect = (gxAnimUseGrowAlloc ? (xAnimEffect*)xMemGrowAlloc(userDataSize + sizeof(xAnimEffect)) : + (xAnimEffect*)xMemAlloc(userDataSize + sizeof(xAnimEffect))); + + effect->Flags = flags; + effect->StartTime = startTime; + effect->EndTime = endTime; + effect->Callback = callback; + + prev = &state->Effects; + curr = state->Effects; + + while (curr && startTime > curr->StartTime) + { + prev = &curr->Next; + curr = curr->Next; + } + + effect->Next = curr; + *prev = effect; + + return effect; +} + +xAnimTable* xAnimTableNew(const char* name, xAnimTable** linkedList, uint32 userFlags) +{ + xAnimTable* table; + + table = (xAnimTable*)xMemAlloc(sizeof(xAnimTable)); + + if (linkedList) + { + table->Next = *linkedList; + *linkedList = table; + } + else + { + table->Next = NULL; + } + + table->Name = name; + table->TransitionList = NULL; + table->StateList = NULL; + table->AnimIndex = NULL; + table->MorphIndex = NULL; + table->UserFlags = userFlags; + + return table; +} + +void xAnimDefaultBeforeEnter(xAnimPlay* play, xAnimState* state) +{ + uint32 entry; + + if (state->MultiFile) + { + entry = rand() % state->MultiFile->Count; + + state->Data = state->MultiFile->Files[entry].File; + } +} + +#ifndef NONMATCHING // xAnimTableNewState(xAnimTable*,const char*,unsigned int,unsigned int,float,float*,float*,float,unsigned short*,void*,void (*)(xAnimPlay*, xAnimState*),void (*)(xAnimState*, xAnimSingle*, void*),void (*)(xAnimPlay*, xQuat*, xVec3*, int)) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableNewState__FP10xAnimTablePCcUiUifPfPffPUsPvPFP9xAnimPlayP10xAnimState_vPFP10xAnimStateP11xAnimSinglePv_vPFP9xAnimPlayP5xQuatP5xVec3i_v") - -// _xAnimTableAddTransitionHelper(xAnimState*,xAnimTransition*,unsigned int&,unsigned int&,xAnimState**) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xAnimTableAddTransitionHelper__FP10xAnimStateP15xAnimTransitionRUiRUiPP10xAnimState") +#pragma GLOBAL_ASM( \ + "asm/Core/x/xAnim.s", \ + "xAnimTableNewState__FP10xAnimTablePCcUiUifPfPffPUsPvPFP9xAnimPlayP10xAnimState_vPFP10xAnimStateP11xAnimSinglePv_vPFP9xAnimPlayP5xQuatP5xVec3i_v") +#else +xAnimState* xAnimTableNewState(xAnimTable* table, const char* name, uint32 flags, uint32 userFlags, + float32 speed, float32* boneBlend, float32* timeSnap, + float32 fadeRecip, uint16* fadeOffset, void* callbackData, + xAnimStateBeforeEnterCallback beforeEnter, + xAnimStateCallback stateCallback, + xAnimStateBeforeAnimMatricesCallback beforeAnimMatrices) +{ + xAnimState* state; + + state = (gxAnimUseGrowAlloc ? (xAnimState*)xMemGrowAlloc(sizeof(xAnimState)) : + (xAnimState*)xMemAlloc(sizeof(xAnimState))); + + if (!table->StateList) + { + state->Next = NULL; + table->StateList = state; + } + else + { + state->Next = table->StateList->Next; + table->StateList->Next = state; + } + + state->Name = name; + state->ID = xStrHash(name); + state->Flags = flags; + state->UserFlags = userFlags; + state->Speed = speed; + state->Data = NULL; + state->Effects = NULL; + state->Default = NULL; + state->List = NULL; + state->BoneBlend = boneBlend; + state->TimeSnap = timeSnap; + state->FadeRecip = (fadeOffset ? CalcRecipBlendMax(fadeOffset) : fadeRecip); + state->FadeOffset = fadeOffset; + state->MultiFile = NULL; + state->CallbackData = callbackData; + state->BeforeEnter = beforeEnter; + state->StateCallback = stateCallback; + state->BeforeAnimMatrices = beforeAnimMatrices; + + return state; +} +#endif + +static void _xAnimTableAddTransitionHelper(xAnimState* state, xAnimTransition* tran, uint32& r5, + uint32& r6, xAnimState** r7) +{ + if (tran->Flags & 0x10) + { + if (!DefaultHasTransition(state, tran, &r5)) + { + r7[r6] = state; + r6++; + } + } + else + { + if (!StateHasTransition(state, tran)) + { + r7[r6] = state; + r6++; + r5++; + } + } +} // _xAnimTableAddTransition(xAnimTable*,xAnimTransition*,const char*,const char*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "_xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCcPCc") +#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", \ + "_xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCcPCc") + +void _xAnimTableAddTransition(xAnimTable* table, xAnimTransition* tran, const char* source, + const char* dest); -// xAnimTableAddTransition(xAnimTable*,xAnimTransition*,const char*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCc") +void xAnimTableAddTransition(xAnimTable* table, xAnimTransition* tran, const char* source) +{ + _xAnimTableAddTransition(table, tran, source, NULL); +} // xAnimTableNewTransition(xAnimTable*,const char*,const char*,unsigned int (*)(xAnimTransition*, xAnimSingle*, void*),unsigned int (*)(xAnimTransition*, xAnimSingle*, void*),unsigned int,unsigned int,float,float,unsigned short,unsigned short,float,unsigned short*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableNewTransition__FP10xAnimTablePCcPCcPFP15xAnimTransitionP11xAnimSinglePv_UiPFP15xAnimTransitionP11xAnimSinglePv_UiUiUiffUsUsfPUs") +#pragma GLOBAL_ASM( \ + "asm/Core/x/xAnim.s", \ + "xAnimTableNewTransition__FP10xAnimTablePCcPCcPFP15xAnimTransitionP11xAnimSinglePv_UiPFP15xAnimTransitionP11xAnimSinglePv_UiUiUiffUsUsfPUs") // xAnimTableAddFile(xAnimTable*,xAnimFile*,const char*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableAddFile__FP10xAnimTableP9xAnimFilePCc") -// xAnimTableAddFileID(xAnimTable*,xAnimFile*,unsigned int,unsigned int,unsigned int) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableAddFileID__FP10xAnimTableP9xAnimFileUiUiUi") - -// xAnimTableGetStateID(xAnimTable*,unsigned int) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableGetStateID__FP10xAnimTableUi") - -// xAnimTableGetState(xAnimTable*,const char*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimTableGetState__FP10xAnimTablePCc") - -// EffectActiveInsert(xAnimSingle*,xAnimActiveEffect*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect") - -// xAnimActiveEffect::operator =(const xAnimActiveEffect&) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "__as__17xAnimActiveEffectFRC17xAnimActiveEffect") - -// EffectActiveRemove(xAnimActiveEffect*,unsigned int,unsigned int) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectActiveRemove__FP17xAnimActiveEffectUiUi") - -// EffectPlaying(xAnimSingle*,xAnimEffect*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectPlaying__FP11xAnimSingleP11xAnimEffect") - -// EffectSingleStart(xAnimSingle*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectSingleStart__FP11xAnimSingle") - -// EffectSingleDuration(xAnimSingle*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectSingleDuration__FP11xAnimSingle") - -// EffectSingleRun(xAnimSingle*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectSingleRun__FP11xAnimSingle") +xAnimState* xAnimTableGetStateID(xAnimTable* table, uint32 ID); + +xAnimState* xAnimTableAddFileID(xAnimTable* table, xAnimFile* file, uint32 stateID, + uint32 subStateID, uint32 subStateCount) +{ + xAnimState* state; + + state = xAnimTableGetStateID(table, stateID); + + if (state) + { + if (subStateID) + { + if (!state->MultiFile) + { + state->MultiFile = + (gxAnimUseGrowAlloc ? + (xAnimMultiFile*)xMemGrowAlloc(subStateCount * + sizeof(xAnimMultiFileEntry) + + sizeof(xAnimMultiFileBase)) : + (xAnimMultiFile*)xMemAlloc(subStateCount * sizeof(xAnimMultiFileEntry) + + sizeof(xAnimMultiFileBase))); + + state->MultiFile->Count = 0; + } + + uint32 count = state->MultiFile->Count; + + state->MultiFile->Files[count].ID = subStateID; + state->MultiFile->Files[count].File = file; + + state->MultiFile->Count++; + } + + state->Data = file; + + if (file->FileFlags & 0x8000) + { + table->MorphIndex |= (1 << (state->Flags & 0xF)); + } + else + { + table->AnimIndex |= (1 << (state->Flags & 0xF)); + } + } + + return state; +} + +xAnimState* xAnimTableGetStateID(xAnimTable* table, uint32 ID) +{ + xAnimState* curr; + + curr = table->StateList; + + while (curr) + { + if (curr->ID == ID) + { + return curr; + } + + curr = curr->Next; + } + + return NULL; +} + +xAnimState* xAnimTableGetState(xAnimTable* table, const char* name) +{ + return xAnimTableGetStateID(table, xStrHash(name)); +} + +static void EffectActiveInsert(xAnimSingle* single, xAnimActiveEffect* active) +{ + uint32 index = 0; + uint32 count = single->ActiveCount; + xAnimActiveEffect* curr = &single->ActiveList[0]; + + while (index < count && curr->Effect) + { + curr++; + index++; + } + + *curr = *active; + + if (index < count - 1) + { + (curr + 1)->Effect = NULL; + } +} + +static void EffectActiveRemove(xAnimActiveEffect* active, uint32 index, uint32 count) +{ + count--; + + if (index == count || !(active + 1)->Effect) + { + active->Effect = NULL; + } + else + { + xAnimActiveEffect* curr = active; + + while (index < count && (curr + 1)->Effect) + { + curr++; + index++; + } + + *active = *curr; + curr->Effect = NULL; + } +} + +static uint32 EffectPlaying(xAnimSingle* single, xAnimEffect* effect) +{ + uint32 index = 0; + + while (index < single->ActiveCount && single->ActiveList[index].Effect) + { + if (single->ActiveList[index].Effect == effect) + { + return TRUE; + } + + index++; + } + + return FALSE; +} + +static void EffectSingleStart(xAnimSingle* single) +{ + xAnimEffect* effect = single->State->Effects; + xAnimActiveEffect tempActive; + float32 time = single->Time; + uint32 flags; + + while (effect && effect->StartTime < time) + { + flags = effect->Flags; + + if (flags & 0x1) + { + if (flags & 0x4) + { + tempActive.Effect = effect; + tempActive.Handle = effect->Callback(1, &tempActive, single, single->Play->Object); + + flags = effect->Flags; + + if (flags & 0x2) + { + if (effect->EndTime <= time) + { + effect->Callback(3, &tempActive, single, single->Play->Object); + } + else + { + EffectActiveInsert(single, &tempActive); + } + } + else if (flags & 0x20) + { + EffectActiveInsert(single, &tempActive); + } + } + else if ((flags & 0x2) && !(flags & 0x10) && effect->EndTime > time) + { + tempActive.Effect = effect; + tempActive.Handle = effect->Callback(1, &tempActive, single, single->Play->Object); + + EffectActiveInsert(single, &tempActive); + } + } + + effect = effect->Next; + } + + single->Effect = effect; +} + +static void EffectSingleDuration(xAnimSingle* single) +{ + float32 time = single->Time; + xAnimActiveEffect* alist = single->ActiveList; + uint32 index = 0; + uint32 count = single->ActiveCount; + + while (index < count && alist->Effect) + { + if (!(alist->Effect->Flags & 0x20) && alist->Effect->EndTime <= time) + { + alist->Effect->Callback(3, alist, single, single->Play->Object); + + EffectActiveRemove(alist, index, count); + } + else + { + alist->Effect->Callback(2, alist, single, single->Play->Object); + + alist++; + index++; + } + } +} + +static void EffectSingleRun(xAnimSingle* single) +{ + xAnimEffect* effect = single->Effect; + xAnimActiveEffect tempActive; + float32 time = single->Time; + uint32 flags; + + while (effect && effect->StartTime <= time) + { + flags = effect->Flags; + + if ((flags & 0x1) && (!(flags & 0x20) || !EffectPlaying(single, effect))) + { + tempActive.Effect = effect; + tempActive.Handle = effect->Callback(1, &tempActive, single, single->Play->Object); + + if (flags & 0x2) + { + if (effect->EndTime <= time) + { + effect->Callback(3, &tempActive, single, single->Play->Object); + } + else + { + EffectActiveInsert(single, &tempActive); + } + } + else if (flags & 0x20) + { + EffectActiveInsert(single, &tempActive); + } + } + + effect = effect->Next; + } + + single->Effect = effect; +} // EffectSingleLoop(xAnimSingle*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectSingleLoop__FP11xAnimSingle") +void EffectSingleLoop(xAnimSingle* single); + // EffectSingleStop(xAnimSingle*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "EffectSingleStop__FP11xAnimSingle") +void EffectSingleStop(xAnimSingle* single); + // StopUpdate(xAnimSingle*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "StopUpdate__FP11xAnimSingle") -// LoopUpdate(xAnimSingle*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "LoopUpdate__FP11xAnimSingle") +static void LoopUpdate(xAnimSingle* single) +{ + float32 time = single->Time; + float32 duration = single->State->Data->Duration; + + if (time > duration) + { + single->Time = duration; + + EffectSingleLoop(single); + + single->Time = time - duration; + } +} // xAnimPlaySetState(xAnimSingle*,xAnimState*,float) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPlaySetState__FP11xAnimSingleP10xAnimStatef") @@ -134,35 +649,202 @@ // SingleUpdate(xAnimSingle*,float) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "SingleUpdate__FP11xAnimSinglef") -// SingleEval(xAnimSingle*,xVec3*,xQuat*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "SingleEval__FP11xAnimSingleP5xVec3P5xQuat") +void SingleUpdate(xAnimSingle* single, float32 timeDelta); -// xAnimPlaySetup(xAnimPlay*,void*,xAnimTable*,xModelInstance*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPlaySetup__FP9xAnimPlayPvP10xAnimTableP14xModelInstance") +static void SingleEval(xAnimSingle* single, xVec3* tran, xQuat* quat) +{ + if (single->Play->BoneCount > 1) + { + xAnimFileEval(single->State->Data, single->Time, single->BilinearLerp, 0x2, tran + 1, + quat + 1, NULL); + + if (single->Blend && single->Blend->State) + { + xQuat* qbuf = (xQuat*)(giAnimScratch + 0xE40); + xVec3* vbuf = (xVec3*)(qbuf + 0x41); -// xAnimPlayChooseTransition(xAnimPlay*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPlayChooseTransition__FP9xAnimPlay") + xAnimFileEval(single->Blend->State->Data, single->Blend->Time, + single->Blend->BilinearLerp, 0x2, vbuf, qbuf, NULL); + + iAnimBlend(single->BlendFactor, single->Tran->BlendRecip, single->Tran->BlendOffset, + NULL, single->Play->BoneCount - 1, vbuf, qbuf, tran + 1, quat + 1, tran + 1, + quat + 1); + } + } +} + +// xAnimPlaySetup(xAnimPlay*,void*,xAnimTable*,xModelInstance*) +#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", \ + "xAnimPlaySetup__FP9xAnimPlayPvP10xAnimTableP14xModelInstance") + +void xAnimPlaySetup(xAnimPlay* play, void* object, xAnimTable* table, xModelInstance* modelInst); + +void xAnimPlayStartTransition(xAnimPlay* play, xAnimTransition* transition); + +void xAnimPlayChooseTransition(xAnimPlay* play) +{ + uint32 i; + void* object = play->Object; + xAnimTransition** list = (xAnimTransition**)giAnimScratch; + xAnimTransition** found; + xAnimTransitionList* curr; + + memset(list, 0, play->NumSingle * sizeof(xAnimTransition*)); + + for (i = 0; i < play->NumSingle; i++) + { + if (play->Single[i].State) + { + curr = play->Single[i].State->List; + + if (curr && curr->T->Conditional) + { + while (curr) + { + if (curr->T->Conditional(curr->T, &play->Single[i], object)) + { + found = &list[curr->T->Dest->Flags & 0xF]; + + if (!*found || curr->T->Priority > (*found)->Priority) + { + *found = curr->T; + } + } + + curr = curr->Next; + } + } + } + } + + for (i = 0; i < play->NumSingle; i++) + { + if (list[i] && + (!play->Single[i].Sync || list[i]->Priority > play->Single[i].Sync->QueuePriority)) + { + xAnimPlayStartTransition(play, list[i]); + } + } +} // xAnimPlayStartTransition(xAnimPlay*,xAnimTransition*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPlayStartTransition__FP9xAnimPlayP15xAnimTransition") -// xAnimPlayUpdate(xAnimPlay*,float) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPlayUpdate__FP9xAnimPlayf") +void xAnimPlayUpdate(xAnimPlay* play, float32 timeDelta) +{ + uint32 i; + xAnimSingle* single; + + for (i = 0; i < play->NumSingle; i++) + { + single = &play->Single[i]; + + SingleUpdate(single, timeDelta); + + if (single->State->StateCallback) + { + single->State->StateCallback(single->State, single, play->Object); + } + } +} // xAnimPlayEval(xAnimPlay*) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPlayEval__FP9xAnimPlay") -// xAnimPoolCB(xMemPool*,void*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPoolCB__FP8xMemPoolPv") +void xAnimPoolCB(xMemPool* pool, void* data) +{ + int32 i; + xAnimPlay* clone = (xAnimPlay*)data; + xAnimPlay* play = (xAnimPlay*)pool->Buffer; + xAnimSingle* clonesingle = (xAnimSingle*)(clone + 1); + xAnimSingle* currsingle; + xAnimActiveEffect* curract; + + clone->NumSingle = play->NumSingle; + clone->Single = clonesingle; + + clonesingle += play->NumSingle; + + for (i = 0; i < play->NumSingle; i++) + { + clone->Single[i].Play = clone; + + if (play->Single[i].Blend) + { + clone->Single[i].Blend = clonesingle; + + clonesingle->Blend = NULL; + clonesingle->Play = clone; + + clonesingle++; + } + else + { + clone->Single[i].Blend = NULL; + } + } + + curract = (xAnimActiveEffect*)clonesingle; + + for (i = 0; i < clone->NumSingle; i++) + { + clonesingle = &clone->Single[i]; + currsingle = &play->Single[i]; + + while (clonesingle) + { + clonesingle->ActiveCount = currsingle->ActiveCount; + + if (currsingle->ActiveCount) + { + clonesingle->ActiveList = curract; + + curract += currsingle->ActiveCount; + } + else + { + clonesingle->ActiveList = NULL; + } + + currsingle = currsingle->Blend; + clonesingle = clonesingle->Blend; + } + } + + clone->Pool = pool; +} // xAnimPoolInit(xMemPool*,unsigned int,unsigned int,unsigned int,unsigned int) #pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPoolInit__FP8xMemPoolUiUiUiUi") -// xAnimPoolAlloc(xMemPool*,void*,xAnimTable*,xModelInstance*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPoolAlloc__FP8xMemPoolPvP10xAnimTableP14xModelInstance") +xAnimPlay* xAnimPoolAlloc(xMemPool* pool, void* object, xAnimTable* table, + xModelInstance* modelInst) +{ + xAnimPlay* play; + + play = (xAnimPlay*)xMemPoolAlloc(pool); + + xAnimPlaySetup(play, object, table, modelInst); + + return play; +} + +void xAnimPoolFree(xAnimPlay* play) +{ + uint32 i; + + for (i = 0; i < play->NumSingle; i++) + { + EffectSingleStop(&play->Single[i]); + + if (play->Single[i].Blend) + { + EffectSingleStop(play->Single[i].Blend); + } + } -// xAnimPoolFree(xAnimPlay*) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimPoolFree__FP9xAnimPlay") + xMemPoolFree(play->Pool, play); +} // xAnimFileRawTime(xAnimFile*,float) -#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimFileRawTime__FP9xAnimFilef") +#pragma GLOBAL_ASM("asm/Core/x/xAnim.s", "xAnimFileRawTime__FP9xAnimFilef") \ No newline at end of file diff --git a/src/Core/x/xAnim.h b/src/Core/x/xAnim.h index 2e3fccea6..7cbf987a1 100644 --- a/src/Core/x/xAnim.h +++ b/src/Core/x/xAnim.h @@ -3,32 +3,124 @@ #include -struct xAnimPlay; - -#include "xModel.h" -#include "xMemMgr.h" #include "xMath3.h" -#include "xVec3.h" +#include "xMemMgr.h" -struct xAnimState; -struct xAnimFile; -struct xAnimMultiFile; -struct xAnimTransitionList; +typedef struct xAnimState; +typedef struct xAnimTransition; +typedef struct xAnimTransitionList; +typedef struct xAnimEffect; +typedef struct xAnimActiveEffect; +typedef struct xAnimSingle; +typedef struct xAnimPlay; -struct xAnimTable +struct xAnimFile { + xAnimFile* Next; + const char* Name; + uint32 ID; + uint32 FileFlags; + float32 Duration; + float32 TimeOffset; + uint16 BoneCount; + uint8 NumAnims[2]; + void** RawData; }; -struct xAnimEffect +struct xAnimMultiFileEntry { + uint32 ID; + xAnimFile* File; }; -struct xAnimActiveEffect +struct xAnimMultiFileBase { + uint32 Count; +}; + +struct xAnimMultiFile : xAnimMultiFileBase +{ + xAnimMultiFileEntry Files[1]; +}; + +typedef void (*xAnimStateBeforeEnterCallback)(xAnimPlay*, xAnimState*); +typedef void (*xAnimStateCallback)(xAnimState*, xAnimSingle*, void*); +typedef void (*xAnimStateBeforeAnimMatricesCallback)(xAnimPlay*, xQuat*, xVec3*, int32); + +struct xAnimState +{ + xAnimState* Next; + const char* Name; + uint32 ID; + uint32 Flags; + uint32 UserFlags; + float32 Speed; + xAnimFile* Data; + xAnimEffect* Effects; + xAnimTransitionList* Default; + xAnimTransitionList* List; + float32* BoneBlend; + float32* TimeSnap; + float32 FadeRecip; + uint16* FadeOffset; + void* CallbackData; + xAnimMultiFile* MultiFile; + xAnimStateBeforeEnterCallback BeforeEnter; + xAnimStateCallback StateCallback; + xAnimStateBeforeAnimMatricesCallback BeforeAnimMatrices; }; +typedef uint32 (*xAnimTransitionConditionalCallback)(xAnimTransition*, xAnimSingle*, void*); +typedef uint32 (*xAnimTransitionCallback)(xAnimTransition*, xAnimSingle*, void*); + struct xAnimTransition { + xAnimTransition* Next; + xAnimState* Dest; + xAnimTransitionConditionalCallback Conditional; + xAnimTransitionCallback Callback; + uint32 Flags; + uint32 UserFlags; + float32 SrcTime; + float32 DestTime; + uint16 Priority; + uint16 QueuePriority; + float32 BlendRecip; + uint16* BlendOffset; +}; + +struct xAnimTransitionList +{ + xAnimTransitionList* Next; + xAnimTransition* T; +}; + +struct xAnimTable +{ + xAnimTable* Next; + const char* Name; + xAnimTransition* TransitionList; + xAnimState* StateList; + uint32 AnimIndex; + uint32 MorphIndex; + uint32 UserFlags; +}; + +typedef uint32 (*xAnimEffectCallback)(uint32, xAnimActiveEffect*, xAnimSingle*, void*); + +struct xAnimEffect +{ + xAnimEffect* Next; + uint32 Flags; + float32 StartTime; + float32 EndTime; + xAnimEffectCallback Callback; +}; + +struct xAnimActiveEffect +{ + xAnimEffect* Effect; + uint32 Handle; }; struct xAnimSingle @@ -50,12 +142,7 @@ struct xAnimSingle uint32 pad; }; -typedef void (*type_7)(xAnimPlay*, xQuat*, xVec3*, int32); - -// have to do this because for some reason -// including xModel.h doesn't put this before -// xAnimPlay is defined, which references it -struct xModelInstance; +typedef struct xModelInstance; struct xAnimPlay { @@ -67,30 +154,9 @@ struct xAnimPlay xAnimTable* Table; xMemPool* Pool; xModelInstance* ModelInst; - type_7 BeforeAnimMatrices; -}; - -struct xAnimState -{ - xAnimState* Next; - int8* Name; - uint32 ID; - uint32 Flags; - uint32 UserFlags; - float32 Speed; - xAnimFile* Data; - xAnimEffect* Effects; - xAnimTransitionList* Default; - xAnimTransitionList* List; - float32* BoneBlend; - float32* TimeSnap; - float32 FadeRecip; - uint16* FadeOffset; - void* CallbackData; - xAnimMultiFile* MultiFile; - void (*BeforeEnter)(xAnimPlay*, xAnimState*); - void (*StateCallback)(xAnimState*, xAnimSingle*, void*); void (*BeforeAnimMatrices)(xAnimPlay*, xQuat*, xVec3*, int32); }; +extern uint32 gxAnimUseGrowAlloc; + #endif \ No newline at end of file From 8b0ee102cb04392abd45ccc3d711daec4ab82ea9 Mon Sep 17 00:00:00 2001 From: seilweiss <32021834+seilweiss@users.noreply.github.com> Date: Fri, 23 Oct 2020 16:03:35 -0500 Subject: [PATCH 2/2] remove decomped functions from assembly --- asm/Core/x/xAnim.s | 1313 -------------------------------------------- 1 file changed, 1313 deletions(-) diff --git a/asm/Core/x/xAnim.s b/asm/Core/x/xAnim.s index d0cd1a2a5..c962f9d61 100644 --- a/asm/Core/x/xAnim.s +++ b/asm/Core/x/xAnim.s @@ -13,88 +13,6 @@ lbl_80251E00: .section .text # 0x800058E0 - 0x80009400 -_xSingleCompare__Fcc: -/* 800058E0 000026E0 54 80 06 3E */ clrlwi r0, r4, 0x18 -/* 800058E4 000026E4 2C 00 00 2C */ cmpwi r0, 0x2c -/* 800058E8 000026E8 40 80 00 1C */ bge lbl_80005904 -/* 800058EC 000026EC 2C 00 00 23 */ cmpwi r0, 0x23 -/* 800058F0 000026F0 41 82 00 28 */ beq lbl_80005918 -/* 800058F4 000026F4 41 80 00 44 */ blt lbl_80005938 -/* 800058F8 000026F8 2C 00 00 2A */ cmpwi r0, 0x2a -/* 800058FC 000026FC 40 80 00 14 */ bge lbl_80005910 -/* 80005900 00002700 48 00 00 38 */ b lbl_80005938 -lbl_80005904: -/* 80005904 00002704 2C 00 00 3F */ cmpwi r0, 0x3f -/* 80005908 00002708 41 82 00 08 */ beq lbl_80005910 -/* 8000590C 0000270C 48 00 00 2C */ b lbl_80005938 -lbl_80005910: -/* 80005910 00002710 38 60 00 01 */ li r3, 1 -/* 80005914 00002714 4E 80 00 20 */ blr -lbl_80005918: -/* 80005918 00002718 54 60 06 3E */ clrlwi r0, r3, 0x18 -/* 8000591C 0000271C 38 60 00 00 */ li r3, 0 -/* 80005920 00002720 28 00 00 30 */ cmplwi r0, 0x30 -/* 80005924 00002724 4D 80 00 20 */ bltlr -/* 80005928 00002728 28 00 00 39 */ cmplwi r0, 0x39 -/* 8000592C 0000272C 4D 81 00 20 */ bgtlr -/* 80005930 00002730 38 60 00 01 */ li r3, 1 -/* 80005934 00002734 4E 80 00 20 */ blr -lbl_80005938: -/* 80005938 00002738 54 63 06 3E */ clrlwi r3, r3, 0x18 -/* 8000593C 0000273C 54 80 06 3E */ clrlwi r0, r4, 0x18 -/* 80005940 00002740 7C 03 00 50 */ subf r0, r3, r0 -/* 80005944 00002744 7C 00 00 34 */ cntlzw r0, r0 -/* 80005948 00002748 54 03 D9 7E */ srwi r3, r0, 5 -/* 8000594C 0000274C 4E 80 00 20 */ blr - -_xSingleCompare__FcPCc: -/* 80005950 00002750 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80005954 00002754 7C 08 02 A6 */ mflr r0 -/* 80005958 00002758 90 01 00 14 */ stw r0, 0x14(r1) -/* 8000595C 0000275C 93 E1 00 0C */ stw r31, 0xc(r1) -/* 80005960 00002760 7C 9F 23 78 */ mr r31, r4 -/* 80005964 00002764 93 C1 00 08 */ stw r30, 8(r1) -/* 80005968 00002768 7C 7E 1B 78 */ mr r30, r3 -/* 8000596C 0000276C 48 00 00 20 */ b lbl_8000598C -lbl_80005970: -/* 80005970 00002770 7F C3 F3 78 */ mr r3, r30 -/* 80005974 00002774 4B FF FF 6D */ bl _xSingleCompare__Fcc -/* 80005978 00002778 54 60 06 3F */ clrlwi. r0, r3, 0x18 -/* 8000597C 0000277C 41 82 00 0C */ beq lbl_80005988 -/* 80005980 00002780 38 60 00 01 */ li r3, 1 -/* 80005984 00002784 48 00 00 18 */ b lbl_8000599C -lbl_80005988: -/* 80005988 00002788 3B FF 00 01 */ addi r31, r31, 1 -lbl_8000598C: -/* 8000598C 0000278C 88 9F 00 00 */ lbz r4, 0(r31) -/* 80005990 00002790 28 04 00 00 */ cmplwi r4, 0 -/* 80005994 00002794 40 82 FF DC */ bne lbl_80005970 -/* 80005998 00002798 38 60 00 00 */ li r3, 0 -lbl_8000599C: -/* 8000599C 0000279C 80 01 00 14 */ lwz r0, 0x14(r1) -/* 800059A0 000027A0 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 800059A4 000027A4 83 C1 00 08 */ lwz r30, 8(r1) -/* 800059A8 000027A8 7C 08 03 A6 */ mtlr r0 -/* 800059AC 000027AC 38 21 00 10 */ addi r1, r1, 0x10 -/* 800059B0 000027B0 4E 80 00 20 */ blr - -_xCharIn__FcPCc: -/* 800059B4 000027B4 54 60 06 3E */ clrlwi r0, r3, 0x18 -/* 800059B8 000027B8 48 00 00 18 */ b lbl_800059D0 -lbl_800059BC: -/* 800059BC 000027BC 7C 00 18 40 */ cmplw r0, r3 -/* 800059C0 000027C0 40 82 00 0C */ bne lbl_800059CC -/* 800059C4 000027C4 38 60 00 01 */ li r3, 1 -/* 800059C8 000027C8 4E 80 00 20 */ blr -lbl_800059CC: -/* 800059CC 000027CC 38 84 00 01 */ addi r4, r4, 1 -lbl_800059D0: -/* 800059D0 000027D0 88 64 00 00 */ lbz r3, 0(r4) -/* 800059D4 000027D4 28 03 00 00 */ cmplwi r3, 0 -/* 800059D8 000027D8 40 82 FF E4 */ bne lbl_800059BC -/* 800059DC 000027DC 38 60 00 00 */ li r3, 0 -/* 800059E0 000027E0 4E 80 00 20 */ blr - _xCheckAnimNameInner__FPCcPCciPcPiPi: /* 800059E4 000027E4 94 21 FF 20 */ stwu r1, -0xe0(r1) /* 800059E8 000027E8 7C 08 02 A6 */ mflr r0 @@ -509,112 +427,6 @@ lbl_80005F38: /* 80005F44 00002D44 38 21 00 E0 */ addi r1, r1, 0xe0 /* 80005F48 00002D48 4E 80 00 20 */ blr -_xCheckAnimName__FPCcPCcPc: -/* 80005F4C 00002D4C 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 80005F50 00002D50 7C 08 02 A6 */ mflr r0 -/* 80005F54 00002D54 90 01 00 24 */ stw r0, 0x24(r1) -/* 80005F58 00002D58 38 00 00 01 */ li r0, 1 -/* 80005F5C 00002D5C 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80005F60 00002D60 7C BF 2B 78 */ mr r31, r5 -/* 80005F64 00002D64 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80005F68 00002D68 7C 9E 23 78 */ mr r30, r4 -/* 80005F6C 00002D6C 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80005F70 00002D70 7C 7D 1B 78 */ mr r29, r3 -/* 80005F74 00002D74 7F C3 F3 78 */ mr r3, r30 -/* 80005F78 00002D78 98 05 00 00 */ stb r0, 0(r5) -/* 80005F7C 00002D7C 48 1E 18 3D */ bl strlen -/* 80005F80 00002D80 7C 60 1B 78 */ mr r0, r3 -/* 80005F84 00002D84 7F A3 EB 78 */ mr r3, r29 -/* 80005F88 00002D88 7C 05 03 78 */ mr r5, r0 -/* 80005F8C 00002D8C 7F C4 F3 78 */ mr r4, r30 -/* 80005F90 00002D90 7F E6 FB 78 */ mr r6, r31 -/* 80005F94 00002D94 38 E1 00 08 */ addi r7, r1, 8 -/* 80005F98 00002D98 39 00 00 00 */ li r8, 0 -/* 80005F9C 00002D9C 4B FF FA 49 */ bl _xCheckAnimNameInner__FPCcPCciPcPiPi -/* 80005FA0 00002DA0 54 60 06 3F */ clrlwi. r0, r3, 0x18 -/* 80005FA4 00002DA4 38 60 00 00 */ li r3, 0 -/* 80005FA8 00002DA8 41 82 00 18 */ beq lbl_80005FC0 -/* 80005FAC 00002DAC 80 01 00 08 */ lwz r0, 8(r1) -/* 80005FB0 00002DB0 7C 1D 00 AE */ lbzx r0, r29, r0 -/* 80005FB4 00002DB4 28 00 00 00 */ cmplwi r0, 0 -/* 80005FB8 00002DB8 40 82 00 08 */ bne lbl_80005FC0 -/* 80005FBC 00002DBC 38 60 00 01 */ li r3, 1 -lbl_80005FC0: -/* 80005FC0 00002DC0 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80005FC4 00002DC4 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80005FC8 00002DC8 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80005FCC 00002DCC 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80005FD0 00002DD0 7C 08 03 A6 */ mtlr r0 -/* 80005FD4 00002DD4 38 21 00 20 */ addi r1, r1, 0x20 -/* 80005FD8 00002DD8 4E 80 00 20 */ blr - -.global xAnimInit__Fv -xAnimInit__Fv: -/* 80005FDC 00002DDC 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80005FE0 00002DE0 7C 08 02 A6 */ mflr r0 -/* 80005FE4 00002DE4 90 01 00 14 */ stw r0, 0x14(r1) -/* 80005FE8 00002DE8 48 0B 8A 0D */ bl iAnimInit__Fv -/* 80005FEC 00002DEC 3C 60 80 2C */ lis r3, sxAnimTempTranPool@ha -/* 80005FF0 00002DF0 38 80 00 00 */ li r4, 0 -/* 80005FF4 00002DF4 38 63 89 E0 */ addi r3, r3, sxAnimTempTranPool@l -/* 80005FF8 00002DF8 38 A0 00 1C */ li r5, 0x1c -/* 80005FFC 00002DFC 4B FF D4 5D */ bl memset -/* 80006000 00002E00 80 01 00 14 */ lwz r0, 0x14(r1) -/* 80006004 00002E04 7C 08 03 A6 */ mtlr r0 -/* 80006008 00002E08 38 21 00 10 */ addi r1, r1, 0x10 -/* 8000600C 00002E0C 4E 80 00 20 */ blr - -.global xAnimTempTransitionInit__FUi -xAnimTempTransitionInit__FUi: -/* 80006010 00002E10 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80006014 00002E14 7C 08 02 A6 */ mflr r0 -/* 80006018 00002E18 38 A0 00 00 */ li r5, 0 -/* 8000601C 00002E1C 90 01 00 14 */ stw r0, 0x14(r1) -/* 80006020 00002E20 93 E1 00 0C */ stw r31, 0xc(r1) -/* 80006024 00002E24 7C 7F 1B 78 */ mr r31, r3 -/* 80006028 00002E28 1C 9F 00 2C */ mulli r4, r31, 0x2c -/* 8000602C 00002E2C 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) -/* 80006030 00002E30 48 02 D9 11 */ bl xMemAlloc__FUiUii -/* 80006034 00002E34 3C A0 80 2C */ lis r5, sxAnimTempTranPool@ha -/* 80006038 00002E38 7C 64 1B 78 */ mr r4, r3 -/* 8000603C 00002E3C 38 65 89 E0 */ addi r3, r5, sxAnimTempTranPool@l -/* 80006040 00002E40 7F E9 FB 78 */ mr r9, r31 -/* 80006044 00002E44 57 EA F8 7E */ srwi r10, r31, 1 -/* 80006048 00002E48 38 A0 00 00 */ li r5, 0 -/* 8000604C 00002E4C 38 C0 00 00 */ li r6, 0 -/* 80006050 00002E50 38 E0 00 00 */ li r7, 0 -/* 80006054 00002E54 39 00 00 2C */ li r8, 0x2c -/* 80006058 00002E58 48 02 DC 91 */ bl xMemPoolSetup__FP8xMemPoolPvUiUiPFP8xMemPoolPv_vUiUiUi -/* 8000605C 00002E5C 80 01 00 14 */ lwz r0, 0x14(r1) -/* 80006060 00002E60 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 80006064 00002E64 7C 08 03 A6 */ mtlr r0 -/* 80006068 00002E68 38 21 00 10 */ addi r1, r1, 0x10 -/* 8000606C 00002E6C 4E 80 00 20 */ blr - -.global xatan2__Fff -xatan2__Fff: -/* 80006070 00002E70 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80006074 00002E74 7C 08 02 A6 */ mflr r0 -/* 80006078 00002E78 90 01 00 14 */ stw r0, 0x14(r1) -/* 8000607C 00002E7C 48 00 00 19 */ bl atan2f__3stdFff -/* 80006080 00002E80 48 02 B0 51 */ bl xAngleClampFast__Ff -/* 80006084 00002E84 80 01 00 14 */ lwz r0, 0x14(r1) -/* 80006088 00002E88 7C 08 03 A6 */ mtlr r0 -/* 8000608C 00002E8C 38 21 00 10 */ addi r1, r1, 0x10 -/* 80006090 00002E90 4E 80 00 20 */ blr - -.global atan2f__3stdFff -atan2f__3stdFff: -/* 80006094 00002E94 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80006098 00002E98 7C 08 02 A6 */ mflr r0 -/* 8000609C 00002E9C 90 01 00 14 */ stw r0, 0x14(r1) -/* 800060A0 00002EA0 48 1E 6A 11 */ bl atan2 -/* 800060A4 00002EA4 80 01 00 14 */ lwz r0, 0x14(r1) -/* 800060A8 00002EA8 FC 20 08 18 */ frsp f1, f1 -/* 800060AC 00002EAC 7C 08 03 A6 */ mtlr r0 -/* 800060B0 00002EB0 38 21 00 10 */ addi r1, r1, 0x10 -/* 800060B4 00002EB4 4E 80 00 20 */ blr - CalcRecipBlendMax__FPUs: /* 800060B8 00002EB8 94 21 FF E0 */ stwu r1, -0x20(r1) /* 800060BC 00002EBC 3C 00 43 30 */ lis r0, 0x4330 @@ -665,78 +477,6 @@ lbl_80006154: /* 80006154 00002F54 38 21 00 20 */ addi r1, r1, 0x20 /* 80006158 00002F58 4E 80 00 20 */ blr -StateHasTransition__FP10xAnimStateP15xAnimTransition: -/* 8000615C 00002F5C 80 63 00 24 */ lwz r3, 0x24(r3) -/* 80006160 00002F60 48 00 00 1C */ b lbl_8000617C -lbl_80006164: -/* 80006164 00002F64 80 03 00 04 */ lwz r0, 4(r3) -/* 80006168 00002F68 7C 00 20 40 */ cmplw r0, r4 -/* 8000616C 00002F6C 40 82 00 0C */ bne lbl_80006178 -/* 80006170 00002F70 38 60 00 01 */ li r3, 1 -/* 80006174 00002F74 4E 80 00 20 */ blr -lbl_80006178: -/* 80006178 00002F78 80 63 00 00 */ lwz r3, 0(r3) -lbl_8000617C: -/* 8000617C 00002F7C 28 03 00 00 */ cmplwi r3, 0 -/* 80006180 00002F80 40 82 FF E4 */ bne lbl_80006164 -/* 80006184 00002F84 38 60 00 00 */ li r3, 0 -/* 80006188 00002F88 4E 80 00 20 */ blr - -DefaultHasTransition__FP10xAnimStateP15xAnimTransitionPUi: -/* 8000618C 00002F8C 81 03 00 20 */ lwz r8, 0x20(r3) -/* 80006190 00002F90 38 E0 00 01 */ li r7, 1 -/* 80006194 00002F94 48 00 00 40 */ b lbl_800061D4 -lbl_80006198: -/* 80006198 00002F98 80 C8 00 04 */ lwz r6, 4(r8) -/* 8000619C 00002F9C 7C 06 20 40 */ cmplw r6, r4 -/* 800061A0 00002FA0 40 82 00 0C */ bne lbl_800061AC -/* 800061A4 00002FA4 38 60 00 01 */ li r3, 1 -/* 800061A8 00002FA8 4E 80 00 20 */ blr -lbl_800061AC: -/* 800061AC 00002FAC 80 66 00 08 */ lwz r3, 8(r6) -/* 800061B0 00002FB0 80 04 00 08 */ lwz r0, 8(r4) -/* 800061B4 00002FB4 7C 03 00 40 */ cmplw r3, r0 -/* 800061B8 00002FB8 40 82 00 18 */ bne lbl_800061D0 -/* 800061BC 00002FBC 80 66 00 14 */ lwz r3, 0x14(r6) -/* 800061C0 00002FC0 80 04 00 14 */ lwz r0, 0x14(r4) -/* 800061C4 00002FC4 7C 03 00 40 */ cmplw r3, r0 -/* 800061C8 00002FC8 40 82 00 08 */ bne lbl_800061D0 -/* 800061CC 00002FCC 38 E0 00 00 */ li r7, 0 -lbl_800061D0: -/* 800061D0 00002FD0 81 08 00 00 */ lwz r8, 0(r8) -lbl_800061D4: -/* 800061D4 00002FD4 28 08 00 00 */ cmplwi r8, 0 -/* 800061D8 00002FD8 40 82 FF C0 */ bne lbl_80006198 -/* 800061DC 00002FDC 80 05 00 00 */ lwz r0, 0(r5) -/* 800061E0 00002FE0 38 60 00 00 */ li r3, 0 -/* 800061E4 00002FE4 7C 00 3A 14 */ add r0, r0, r7 -/* 800061E8 00002FE8 90 05 00 00 */ stw r0, 0(r5) -/* 800061EC 00002FEC 4E 80 00 20 */ blr - -DefaultOverride__FP10xAnimStateP15xAnimTransition: -/* 800061F0 00002FF0 80 C3 00 20 */ lwz r6, 0x20(r3) -/* 800061F4 00002FF4 48 00 00 38 */ b lbl_8000622C -lbl_800061F8: -/* 800061F8 00002FF8 80 A6 00 04 */ lwz r5, 4(r6) -/* 800061FC 00002FFC 80 04 00 08 */ lwz r0, 8(r4) -/* 80006200 00003000 80 65 00 08 */ lwz r3, 8(r5) -/* 80006204 00003004 7C 03 00 40 */ cmplw r3, r0 -/* 80006208 00003008 40 82 00 20 */ bne lbl_80006228 -/* 8000620C 0000300C 80 65 00 14 */ lwz r3, 0x14(r5) -/* 80006210 00003010 80 04 00 14 */ lwz r0, 0x14(r4) -/* 80006214 00003014 7C 03 00 40 */ cmplw r3, r0 -/* 80006218 00003018 40 82 00 10 */ bne lbl_80006228 -/* 8000621C 0000301C 90 86 00 04 */ stw r4, 4(r6) -/* 80006220 00003020 38 60 00 01 */ li r3, 1 -/* 80006224 00003024 4E 80 00 20 */ blr -lbl_80006228: -/* 80006228 00003028 80 C6 00 00 */ lwz r6, 0(r6) -lbl_8000622C: -/* 8000622C 0000302C 28 06 00 00 */ cmplwi r6, 0 -/* 80006230 00003030 40 82 FF C8 */ bne lbl_800061F8 -/* 80006234 00003034 38 60 00 00 */ li r3, 0 -/* 80006238 00003038 4E 80 00 20 */ blr - TransitionTimeInit__FP11xAnimSingleP15xAnimTransition: /* 8000623C 0000303C 94 21 FF F0 */ stwu r1, -0x10(r1) /* 80006240 00003040 7C 08 02 A6 */ mflr r0 @@ -968,21 +708,6 @@ lbl_80006544: /* 80006560 00003360 38 21 00 30 */ addi r1, r1, 0x30 /* 80006564 00003364 4E 80 00 20 */ blr -.global xAnimFileNew__FPvPCcUiPP9xAnimFile -xAnimFileNew__FPvPCcUiPP9xAnimFile: -/* 80006568 00003368 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 8000656C 0000336C 7C 08 02 A6 */ mflr r0 -/* 80006570 00003370 38 E0 00 01 */ li r7, 1 -/* 80006574 00003374 39 00 00 01 */ li r8, 1 -/* 80006578 00003378 90 01 00 14 */ stw r0, 0x14(r1) -/* 8000657C 0000337C 90 61 00 08 */ stw r3, 8(r1) -/* 80006580 00003380 38 61 00 08 */ addi r3, r1, 8 -/* 80006584 00003384 4B FF FD 7D */ bl xAnimFileNewBilinear__FPPvPCcUiPP9xAnimFileUiUi -/* 80006588 00003388 80 01 00 14 */ lwz r0, 0x14(r1) -/* 8000658C 0000338C 7C 08 03 A6 */ mtlr r0 -/* 80006590 00003390 38 21 00 10 */ addi r1, r1, 0x10 -/* 80006594 00003394 4E 80 00 20 */ blr - .global xAnimFileSetTime__FP9xAnimFileff xAnimFileSetTime__FP9xAnimFileff: /* 80006598 00003398 94 21 FF D0 */ stwu r1, -0x30(r1) @@ -1403,134 +1128,6 @@ floorf__3stdFf: /* 80006B94 00003994 38 21 00 10 */ addi r1, r1, 0x10 /* 80006B98 00003998 4E 80 00 20 */ blr -.global xAnimStateNewEffect__FP10xAnimStateUiffPFUiP17xAnimActiveEffectP11xAnimSinglePv_UiUi -xAnimStateNewEffect__FP10xAnimStateUiffPFUiP17xAnimActiveEffectP11xAnimSinglePv_UiUi: -/* 80006B9C 0000399C 94 21 FF C0 */ stwu r1, -0x40(r1) -/* 80006BA0 000039A0 7C 08 02 A6 */ mflr r0 -/* 80006BA4 000039A4 90 01 00 44 */ stw r0, 0x44(r1) -/* 80006BA8 000039A8 DB E1 00 30 */ stfd f31, 0x30(r1) -/* 80006BAC 000039AC F3 E1 00 38 */ psq_st f31, 56(r1), 0, qr0 -/* 80006BB0 000039B0 DB C1 00 20 */ stfd f30, 0x20(r1) -/* 80006BB4 000039B4 F3 C1 00 28 */ psq_st f30, 40(r1), 0, qr0 -/* 80006BB8 000039B8 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80006BBC 000039BC 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80006BC0 000039C0 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80006BC4 000039C4 80 0D 88 60 */ lwz r0, gxAnimUseGrowAlloc-_SDA_BASE_(r13) -/* 80006BC8 000039C8 FF C0 08 90 */ fmr f30, f1 -/* 80006BCC 000039CC FF E0 10 90 */ fmr f31, f2 -/* 80006BD0 000039D0 7C 7D 1B 78 */ mr r29, r3 -/* 80006BD4 000039D4 28 00 00 00 */ cmplwi r0, 0 -/* 80006BD8 000039D8 7C 9E 23 78 */ mr r30, r4 -/* 80006BDC 000039DC 7C BF 2B 78 */ mr r31, r5 -/* 80006BE0 000039E0 41 82 00 14 */ beq lbl_80006BF4 -/* 80006BE4 000039E4 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) -/* 80006BE8 000039E8 38 86 00 14 */ addi r4, r6, 0x14 -/* 80006BEC 000039EC 48 02 CC 79 */ bl xMemGrowAlloc__FUiUi -/* 80006BF0 000039F0 48 00 00 14 */ b lbl_80006C04 -lbl_80006BF4: -/* 80006BF4 000039F4 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) -/* 80006BF8 000039F8 38 86 00 14 */ addi r4, r6, 0x14 -/* 80006BFC 000039FC 38 A0 00 00 */ li r5, 0 -/* 80006C00 00003A00 48 02 CD 41 */ bl xMemAlloc__FUiUii -lbl_80006C04: -/* 80006C04 00003A04 93 C3 00 04 */ stw r30, 4(r3) -/* 80006C08 00003A08 38 BD 00 1C */ addi r5, r29, 0x1c -/* 80006C0C 00003A0C D3 C3 00 08 */ stfs f30, 8(r3) -/* 80006C10 00003A10 D3 E3 00 0C */ stfs f31, 0xc(r3) -/* 80006C14 00003A14 93 E3 00 10 */ stw r31, 0x10(r3) -/* 80006C18 00003A18 80 9D 00 1C */ lwz r4, 0x1c(r29) -/* 80006C1C 00003A1C 48 00 00 0C */ b lbl_80006C28 -lbl_80006C20: -/* 80006C20 00003A20 7C 85 23 78 */ mr r5, r4 -/* 80006C24 00003A24 80 84 00 00 */ lwz r4, 0(r4) -lbl_80006C28: -/* 80006C28 00003A28 28 04 00 00 */ cmplwi r4, 0 -/* 80006C2C 00003A2C 41 82 00 10 */ beq lbl_80006C3C -/* 80006C30 00003A30 C0 04 00 08 */ lfs f0, 8(r4) -/* 80006C34 00003A34 FC 1E 00 40 */ fcmpo cr0, f30, f0 -/* 80006C38 00003A38 41 81 FF E8 */ bgt lbl_80006C20 -lbl_80006C3C: -/* 80006C3C 00003A3C 90 83 00 00 */ stw r4, 0(r3) -/* 80006C40 00003A40 90 65 00 00 */ stw r3, 0(r5) -/* 80006C44 00003A44 E3 E1 00 38 */ psq_l f31, 56(r1), 0, qr0 -/* 80006C48 00003A48 CB E1 00 30 */ lfd f31, 0x30(r1) -/* 80006C4C 00003A4C E3 C1 00 28 */ psq_l f30, 40(r1), 0, qr0 -/* 80006C50 00003A50 CB C1 00 20 */ lfd f30, 0x20(r1) -/* 80006C54 00003A54 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80006C58 00003A58 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80006C5C 00003A5C 80 01 00 44 */ lwz r0, 0x44(r1) -/* 80006C60 00003A60 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80006C64 00003A64 7C 08 03 A6 */ mtlr r0 -/* 80006C68 00003A68 38 21 00 40 */ addi r1, r1, 0x40 -/* 80006C6C 00003A6C 4E 80 00 20 */ blr - -.global xAnimTableNew__FPCcPP10xAnimTableUi -xAnimTableNew__FPCcPP10xAnimTableUi: -/* 80006C70 00003A70 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 80006C74 00003A74 7C 08 02 A6 */ mflr r0 -/* 80006C78 00003A78 90 01 00 24 */ stw r0, 0x24(r1) -/* 80006C7C 00003A7C 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80006C80 00003A80 7C BF 2B 78 */ mr r31, r5 -/* 80006C84 00003A84 38 A0 00 00 */ li r5, 0 -/* 80006C88 00003A88 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80006C8C 00003A8C 7C 9E 23 78 */ mr r30, r4 -/* 80006C90 00003A90 38 80 00 1C */ li r4, 0x1c -/* 80006C94 00003A94 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80006C98 00003A98 7C 7D 1B 78 */ mr r29, r3 -/* 80006C9C 00003A9C 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) -/* 80006CA0 00003AA0 48 02 CC A1 */ bl xMemAlloc__FUiUii -/* 80006CA4 00003AA4 28 1E 00 00 */ cmplwi r30, 0 -/* 80006CA8 00003AA8 41 82 00 14 */ beq lbl_80006CBC -/* 80006CAC 00003AAC 80 1E 00 00 */ lwz r0, 0(r30) -/* 80006CB0 00003AB0 90 03 00 00 */ stw r0, 0(r3) -/* 80006CB4 00003AB4 90 7E 00 00 */ stw r3, 0(r30) -/* 80006CB8 00003AB8 48 00 00 0C */ b lbl_80006CC4 -lbl_80006CBC: -/* 80006CBC 00003ABC 38 00 00 00 */ li r0, 0 -/* 80006CC0 00003AC0 90 03 00 00 */ stw r0, 0(r3) -lbl_80006CC4: -/* 80006CC4 00003AC4 93 A3 00 04 */ stw r29, 4(r3) -/* 80006CC8 00003AC8 38 00 00 00 */ li r0, 0 -/* 80006CCC 00003ACC 90 03 00 08 */ stw r0, 8(r3) -/* 80006CD0 00003AD0 90 03 00 0C */ stw r0, 0xc(r3) -/* 80006CD4 00003AD4 90 03 00 10 */ stw r0, 0x10(r3) -/* 80006CD8 00003AD8 90 03 00 14 */ stw r0, 0x14(r3) -/* 80006CDC 00003ADC 93 E3 00 18 */ stw r31, 0x18(r3) -/* 80006CE0 00003AE0 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80006CE4 00003AE4 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80006CE8 00003AE8 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80006CEC 00003AEC 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80006CF0 00003AF0 7C 08 03 A6 */ mtlr r0 -/* 80006CF4 00003AF4 38 21 00 20 */ addi r1, r1, 0x20 -/* 80006CF8 00003AF8 4E 80 00 20 */ blr - -.global xAnimDefaultBeforeEnter__FP9xAnimPlayP10xAnimState -xAnimDefaultBeforeEnter__FP9xAnimPlayP10xAnimState: -/* 80006CFC 00003AFC 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80006D00 00003B00 7C 08 02 A6 */ mflr r0 -/* 80006D04 00003B04 90 01 00 14 */ stw r0, 0x14(r1) -/* 80006D08 00003B08 93 E1 00 0C */ stw r31, 0xc(r1) -/* 80006D0C 00003B0C 7C 9F 23 78 */ mr r31, r4 -/* 80006D10 00003B10 80 04 00 3C */ lwz r0, 0x3c(r4) -/* 80006D14 00003B14 28 00 00 00 */ cmplwi r0, 0 -/* 80006D18 00003B18 41 82 00 2C */ beq lbl_80006D44 -/* 80006D1C 00003B1C 48 1D F4 C5 */ bl rand -/* 80006D20 00003B20 80 BF 00 3C */ lwz r5, 0x3c(r31) -/* 80006D24 00003B24 80 85 00 00 */ lwz r4, 0(r5) -/* 80006D28 00003B28 7C 03 23 96 */ divwu r0, r3, r4 -/* 80006D2C 00003B2C 7C 00 21 D6 */ mullw r0, r0, r4 -/* 80006D30 00003B30 7C 00 18 50 */ subf r0, r0, r3 -/* 80006D34 00003B34 54 00 18 38 */ slwi r0, r0, 3 -/* 80006D38 00003B38 7C 65 02 14 */ add r3, r5, r0 -/* 80006D3C 00003B3C 80 03 00 08 */ lwz r0, 8(r3) -/* 80006D40 00003B40 90 1F 00 18 */ stw r0, 0x18(r31) -lbl_80006D44: -/* 80006D44 00003B44 80 01 00 14 */ lwz r0, 0x14(r1) -/* 80006D48 00003B48 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 80006D4C 00003B4C 7C 08 03 A6 */ mtlr r0 -/* 80006D50 00003B50 38 21 00 10 */ addi r1, r1, 0x10 -/* 80006D54 00003B54 4E 80 00 20 */ blr - .global xAnimTableNewState__FP10xAnimTablePCcUiUifPfPffPUsPvPFP9xAnimPlayP10xAnimState_vPFP10xAnimStateP11xAnimSinglePv_vPFP9xAnimPlayP5xQuatP5xVec3i_v xAnimTableNewState__FP10xAnimTablePCcUiUifPfPffPUsPvPFP9xAnimPlayP10xAnimState_vPFP10xAnimStateP11xAnimSinglePv_vPFP9xAnimPlayP5xQuatP5xVec3i_v: /* 80006D58 00003B58 94 21 FF B0 */ stwu r1, -0x50(r1) @@ -1618,54 +1215,6 @@ lbl_80006E50: /* 80006E88 00003C88 38 21 00 50 */ addi r1, r1, 0x50 /* 80006E8C 00003C8C 4E 80 00 20 */ blr -_xAnimTableAddTransitionHelper__FP10xAnimStateP15xAnimTransitionRUiRUiPP10xAnimState: -/* 80006E90 00003C90 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 80006E94 00003C94 7C 08 02 A6 */ mflr r0 -/* 80006E98 00003C98 90 01 00 24 */ stw r0, 0x24(r1) -/* 80006E9C 00003C9C 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80006EA0 00003CA0 7C FF 3B 78 */ mr r31, r7 -/* 80006EA4 00003CA4 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80006EA8 00003CA8 7C DE 33 78 */ mr r30, r6 -/* 80006EAC 00003CAC 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80006EB0 00003CB0 7C BD 2B 78 */ mr r29, r5 -/* 80006EB4 00003CB4 93 81 00 10 */ stw r28, 0x10(r1) -/* 80006EB8 00003CB8 7C 7C 1B 78 */ mr r28, r3 -/* 80006EBC 00003CBC 80 04 00 10 */ lwz r0, 0x10(r4) -/* 80006EC0 00003CC0 54 00 06 F7 */ rlwinm. r0, r0, 0, 0x1b, 0x1b -/* 80006EC4 00003CC4 41 82 00 2C */ beq lbl_80006EF0 -/* 80006EC8 00003CC8 4B FF F2 C5 */ bl DefaultHasTransition__FP10xAnimStateP15xAnimTransitionPUi -/* 80006ECC 00003CCC 28 03 00 00 */ cmplwi r3, 0 -/* 80006ED0 00003CD0 40 82 00 50 */ bne lbl_80006F20 -/* 80006ED4 00003CD4 80 1E 00 00 */ lwz r0, 0(r30) -/* 80006ED8 00003CD8 54 00 10 3A */ slwi r0, r0, 2 -/* 80006EDC 00003CDC 7F 9F 01 2E */ stwx r28, r31, r0 -/* 80006EE0 00003CE0 80 7E 00 00 */ lwz r3, 0(r30) -/* 80006EE4 00003CE4 38 03 00 01 */ addi r0, r3, 1 -/* 80006EE8 00003CE8 90 1E 00 00 */ stw r0, 0(r30) -/* 80006EEC 00003CEC 48 00 00 34 */ b lbl_80006F20 -lbl_80006EF0: -/* 80006EF0 00003CF0 4B FF F2 6D */ bl StateHasTransition__FP10xAnimStateP15xAnimTransition -/* 80006EF4 00003CF4 28 03 00 00 */ cmplwi r3, 0 -/* 80006EF8 00003CF8 40 82 00 28 */ bne lbl_80006F20 -/* 80006EFC 00003CFC 80 1E 00 00 */ lwz r0, 0(r30) -/* 80006F00 00003D00 54 00 10 3A */ slwi r0, r0, 2 -/* 80006F04 00003D04 7F 9F 01 2E */ stwx r28, r31, r0 -/* 80006F08 00003D08 80 7E 00 00 */ lwz r3, 0(r30) -/* 80006F0C 00003D0C 38 03 00 01 */ addi r0, r3, 1 -/* 80006F10 00003D10 90 1E 00 00 */ stw r0, 0(r30) -/* 80006F14 00003D14 80 7D 00 00 */ lwz r3, 0(r29) -/* 80006F18 00003D18 38 03 00 01 */ addi r0, r3, 1 -/* 80006F1C 00003D1C 90 1D 00 00 */ stw r0, 0(r29) -lbl_80006F20: -/* 80006F20 00003D20 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80006F24 00003D24 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80006F28 00003D28 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80006F2C 00003D2C 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80006F30 00003D30 83 81 00 10 */ lwz r28, 0x10(r1) -/* 80006F34 00003D34 7C 08 03 A6 */ mtlr r0 -/* 80006F38 00003D38 38 21 00 20 */ addi r1, r1, 0x20 -/* 80006F3C 00003D3C 4E 80 00 20 */ blr - _xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCcPCc: /* 80006F40 00003D40 94 21 FE 20 */ stwu r1, -0x1e0(r1) /* 80006F44 00003D44 7C 08 02 A6 */ mflr r0 @@ -1992,18 +1541,6 @@ lbl_80007388: /* 80007394 00004194 38 21 01 E0 */ addi r1, r1, 0x1e0 /* 80007398 00004198 4E 80 00 20 */ blr -.global xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCc -xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCc: -/* 8000739C 0000419C 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 800073A0 000041A0 7C 08 02 A6 */ mflr r0 -/* 800073A4 000041A4 38 C0 00 00 */ li r6, 0 -/* 800073A8 000041A8 90 01 00 14 */ stw r0, 0x14(r1) -/* 800073AC 000041AC 4B FF FB 95 */ bl _xAnimTableAddTransition__FP10xAnimTableP15xAnimTransitionPCcPCc -/* 800073B0 000041B0 80 01 00 14 */ lwz r0, 0x14(r1) -/* 800073B4 000041B4 7C 08 03 A6 */ mtlr r0 -/* 800073B8 000041B8 38 21 00 10 */ addi r1, r1, 0x10 -/* 800073BC 000041BC 4E 80 00 20 */ blr - .global xAnimTableNewTransition__FP10xAnimTablePCcPCcPFP15xAnimTransitionP11xAnimSinglePv_UiPFP15xAnimTransitionP11xAnimSinglePv_UiUiUiffUsUsfPUs xAnimTableNewTransition__FP10xAnimTablePCcPCcPFP15xAnimTransitionP11xAnimSinglePv_UiPFP15xAnimTransitionP11xAnimSinglePv_UiUiUiffUsUsfPUs: /* 800073C0 000041C0 94 21 FF 90 */ stwu r1, -0x70(r1) @@ -2179,474 +1716,6 @@ lbl_800075F0: /* 80007610 00004410 38 21 00 20 */ addi r1, r1, 0x20 /* 80007614 00004414 4E 80 00 20 */ blr -.global xAnimTableAddFileID__FP10xAnimTableP9xAnimFileUiUiUi -xAnimTableAddFileID__FP10xAnimTableP9xAnimFileUiUiUi: -/* 80007618 00004418 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 8000761C 0000441C 7C 08 02 A6 */ mflr r0 -/* 80007620 00004420 90 01 00 24 */ stw r0, 0x24(r1) -/* 80007624 00004424 BF 61 00 0C */ stmw r27, 0xc(r1) -/* 80007628 00004428 7C 9D 23 78 */ mr r29, r4 -/* 8000762C 0000442C 7C 7C 1B 78 */ mr r28, r3 -/* 80007630 00004430 7C DE 33 78 */ mr r30, r6 -/* 80007634 00004434 7C FB 3B 78 */ mr r27, r7 -/* 80007638 00004438 7C A4 2B 78 */ mr r4, r5 -/* 8000763C 0000443C 48 00 00 F9 */ bl xAnimTableGetStateID__FP10xAnimTableUi -/* 80007640 00004440 7C 7F 1B 79 */ or. r31, r3, r3 -/* 80007644 00004444 41 82 00 D8 */ beq lbl_8000771C -/* 80007648 00004448 28 1E 00 00 */ cmplwi r30, 0 -/* 8000764C 0000444C 41 82 00 84 */ beq lbl_800076D0 -/* 80007650 00004450 80 1F 00 3C */ lwz r0, 0x3c(r31) -/* 80007654 00004454 28 00 00 00 */ cmplwi r0, 0 -/* 80007658 00004458 40 82 00 48 */ bne lbl_800076A0 -/* 8000765C 0000445C 80 0D 88 60 */ lwz r0, gxAnimUseGrowAlloc-_SDA_BASE_(r13) -/* 80007660 00004460 28 00 00 00 */ cmplwi r0, 0 -/* 80007664 00004464 41 82 00 18 */ beq lbl_8000767C -/* 80007668 00004468 57 64 18 38 */ slwi r4, r27, 3 -/* 8000766C 0000446C 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) -/* 80007670 00004470 38 84 00 04 */ addi r4, r4, 4 -/* 80007674 00004474 48 02 C1 F1 */ bl xMemGrowAlloc__FUiUi -/* 80007678 00004478 48 00 00 18 */ b lbl_80007690 -lbl_8000767C: -/* 8000767C 0000447C 57 64 18 38 */ slwi r4, r27, 3 -/* 80007680 00004480 80 6D 89 E0 */ lwz r3, gActiveHeap-_SDA_BASE_(r13) -/* 80007684 00004484 38 84 00 04 */ addi r4, r4, 4 -/* 80007688 00004488 38 A0 00 00 */ li r5, 0 -/* 8000768C 0000448C 48 02 C2 B5 */ bl xMemAlloc__FUiUii -lbl_80007690: -/* 80007690 00004490 90 7F 00 3C */ stw r3, 0x3c(r31) -/* 80007694 00004494 38 00 00 00 */ li r0, 0 -/* 80007698 00004498 80 7F 00 3C */ lwz r3, 0x3c(r31) -/* 8000769C 0000449C 90 03 00 00 */ stw r0, 0(r3) -lbl_800076A0: -/* 800076A0 000044A0 80 7F 00 3C */ lwz r3, 0x3c(r31) -/* 800076A4 000044A4 80 03 00 00 */ lwz r0, 0(r3) -/* 800076A8 000044A8 54 04 18 38 */ slwi r4, r0, 3 -/* 800076AC 000044AC 7C 63 22 14 */ add r3, r3, r4 -/* 800076B0 000044B0 93 C3 00 04 */ stw r30, 4(r3) -/* 800076B4 000044B4 80 1F 00 3C */ lwz r0, 0x3c(r31) -/* 800076B8 000044B8 7C 60 22 14 */ add r3, r0, r4 -/* 800076BC 000044BC 93 A3 00 08 */ stw r29, 8(r3) -/* 800076C0 000044C0 80 9F 00 3C */ lwz r4, 0x3c(r31) -/* 800076C4 000044C4 80 64 00 00 */ lwz r3, 0(r4) -/* 800076C8 000044C8 38 03 00 01 */ addi r0, r3, 1 -/* 800076CC 000044CC 90 04 00 00 */ stw r0, 0(r4) -lbl_800076D0: -/* 800076D0 000044D0 93 BF 00 18 */ stw r29, 0x18(r31) -/* 800076D4 000044D4 80 1D 00 0C */ lwz r0, 0xc(r29) -/* 800076D8 000044D8 54 00 04 21 */ rlwinm. r0, r0, 0, 0x10, 0x10 -/* 800076DC 000044DC 41 82 00 24 */ beq lbl_80007700 -/* 800076E0 000044E0 80 1F 00 0C */ lwz r0, 0xc(r31) -/* 800076E4 000044E4 38 60 00 01 */ li r3, 1 -/* 800076E8 000044E8 80 9C 00 14 */ lwz r4, 0x14(r28) -/* 800076EC 000044EC 54 00 07 3E */ clrlwi r0, r0, 0x1c -/* 800076F0 000044F0 7C 60 00 30 */ slw r0, r3, r0 -/* 800076F4 000044F4 7C 80 03 78 */ or r0, r4, r0 -/* 800076F8 000044F8 90 1C 00 14 */ stw r0, 0x14(r28) -/* 800076FC 000044FC 48 00 00 20 */ b lbl_8000771C -lbl_80007700: -/* 80007700 00004500 80 1F 00 0C */ lwz r0, 0xc(r31) -/* 80007704 00004504 38 60 00 01 */ li r3, 1 -/* 80007708 00004508 80 9C 00 10 */ lwz r4, 0x10(r28) -/* 8000770C 0000450C 54 00 07 3E */ clrlwi r0, r0, 0x1c -/* 80007710 00004510 7C 60 00 30 */ slw r0, r3, r0 -/* 80007714 00004514 7C 80 03 78 */ or r0, r4, r0 -/* 80007718 00004518 90 1C 00 10 */ stw r0, 0x10(r28) -lbl_8000771C: -/* 8000771C 0000451C 7F E3 FB 78 */ mr r3, r31 -/* 80007720 00004520 BB 61 00 0C */ lmw r27, 0xc(r1) -/* 80007724 00004524 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80007728 00004528 7C 08 03 A6 */ mtlr r0 -/* 8000772C 0000452C 38 21 00 20 */ addi r1, r1, 0x20 -/* 80007730 00004530 4E 80 00 20 */ blr - -.global xAnimTableGetStateID__FP10xAnimTableUi -xAnimTableGetStateID__FP10xAnimTableUi: -/* 80007734 00004534 80 63 00 0C */ lwz r3, 0xc(r3) -/* 80007738 00004538 48 00 00 14 */ b lbl_8000774C -lbl_8000773C: -/* 8000773C 0000453C 80 03 00 08 */ lwz r0, 8(r3) -/* 80007740 00004540 7C 00 20 40 */ cmplw r0, r4 -/* 80007744 00004544 4D 82 00 20 */ beqlr -/* 80007748 00004548 80 63 00 00 */ lwz r3, 0(r3) -lbl_8000774C: -/* 8000774C 0000454C 28 03 00 00 */ cmplwi r3, 0 -/* 80007750 00004550 40 82 FF EC */ bne lbl_8000773C -/* 80007754 00004554 38 60 00 00 */ li r3, 0 -/* 80007758 00004558 4E 80 00 20 */ blr - -.global xAnimTableGetState__FP10xAnimTablePCc -xAnimTableGetState__FP10xAnimTablePCc: -/* 8000775C 0000455C 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 80007760 00004560 7C 08 02 A6 */ mflr r0 -/* 80007764 00004564 90 01 00 14 */ stw r0, 0x14(r1) -/* 80007768 00004568 93 E1 00 0C */ stw r31, 0xc(r1) -/* 8000776C 0000456C 7C 7F 1B 78 */ mr r31, r3 -/* 80007770 00004570 7C 83 23 78 */ mr r3, r4 -/* 80007774 00004574 48 04 4A A1 */ bl xStrHash__FPCc -/* 80007778 00004578 7C 64 1B 78 */ mr r4, r3 -/* 8000777C 0000457C 7F E3 FB 78 */ mr r3, r31 -/* 80007780 00004580 4B FF FF B5 */ bl xAnimTableGetStateID__FP10xAnimTableUi -/* 80007784 00004584 80 01 00 14 */ lwz r0, 0x14(r1) -/* 80007788 00004588 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 8000778C 0000458C 7C 08 03 A6 */ mtlr r0 -/* 80007790 00004590 38 21 00 10 */ addi r1, r1, 0x10 -/* 80007794 00004594 4E 80 00 20 */ blr - -EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect: -/* 80007798 00004598 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 8000779C 0000459C 7C 08 02 A6 */ mflr r0 -/* 800077A0 000045A0 90 01 00 24 */ stw r0, 0x24(r1) -/* 800077A4 000045A4 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 800077A8 000045A8 3B E0 00 00 */ li r31, 0 -/* 800077AC 000045AC 93 C1 00 18 */ stw r30, 0x18(r1) -/* 800077B0 000045B0 93 A1 00 14 */ stw r29, 0x14(r1) -/* 800077B4 000045B4 83 C3 00 1C */ lwz r30, 0x1c(r3) -/* 800077B8 000045B8 83 A3 00 24 */ lwz r29, 0x24(r3) -/* 800077BC 000045BC 48 00 00 0C */ b lbl_800077C8 -lbl_800077C0: -/* 800077C0 000045C0 3B BD 00 08 */ addi r29, r29, 8 -/* 800077C4 000045C4 3B FF 00 01 */ addi r31, r31, 1 -lbl_800077C8: -/* 800077C8 000045C8 7C 1F F0 40 */ cmplw r31, r30 -/* 800077CC 000045CC 40 80 00 10 */ bge lbl_800077DC -/* 800077D0 000045D0 80 1D 00 00 */ lwz r0, 0(r29) -/* 800077D4 000045D4 28 00 00 00 */ cmplwi r0, 0 -/* 800077D8 000045D8 40 82 FF E8 */ bne lbl_800077C0 -lbl_800077DC: -/* 800077DC 000045DC 7F A3 EB 78 */ mr r3, r29 -/* 800077E0 000045E0 48 00 00 35 */ bl __as__17xAnimActiveEffectFRC17xAnimActiveEffect -/* 800077E4 000045E4 38 1E FF FF */ addi r0, r30, -1 -/* 800077E8 000045E8 7C 1F 00 40 */ cmplw r31, r0 -/* 800077EC 000045EC 40 80 00 0C */ bge lbl_800077F8 -/* 800077F0 000045F0 38 00 00 00 */ li r0, 0 -/* 800077F4 000045F4 90 1D 00 08 */ stw r0, 8(r29) -lbl_800077F8: -/* 800077F8 000045F8 80 01 00 24 */ lwz r0, 0x24(r1) -/* 800077FC 000045FC 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80007800 00004600 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80007804 00004604 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80007808 00004608 7C 08 03 A6 */ mtlr r0 -/* 8000780C 0000460C 38 21 00 20 */ addi r1, r1, 0x20 -/* 80007810 00004610 4E 80 00 20 */ blr - -.global __as__17xAnimActiveEffectFRC17xAnimActiveEffect -__as__17xAnimActiveEffectFRC17xAnimActiveEffect: -/* 80007814 00004614 80 A4 00 00 */ lwz r5, 0(r4) -/* 80007818 00004618 80 04 00 04 */ lwz r0, 4(r4) -/* 8000781C 0000461C 90 A3 00 00 */ stw r5, 0(r3) -/* 80007820 00004620 90 03 00 04 */ stw r0, 4(r3) -/* 80007824 00004624 4E 80 00 20 */ blr - -EffectActiveRemove__FP17xAnimActiveEffectUiUi: -/* 80007828 00004628 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 8000782C 0000462C 7C 08 02 A6 */ mflr r0 -/* 80007830 00004630 38 A5 FF FF */ addi r5, r5, -1 -/* 80007834 00004634 90 01 00 14 */ stw r0, 0x14(r1) -/* 80007838 00004638 7C 04 28 40 */ cmplw r4, r5 -/* 8000783C 0000463C 93 E1 00 0C */ stw r31, 0xc(r1) -/* 80007840 00004640 41 82 00 10 */ beq lbl_80007850 -/* 80007844 00004644 80 03 00 08 */ lwz r0, 8(r3) -/* 80007848 00004648 28 00 00 00 */ cmplwi r0, 0 -/* 8000784C 0000464C 40 82 00 10 */ bne lbl_8000785C -lbl_80007850: -/* 80007850 00004650 38 00 00 00 */ li r0, 0 -/* 80007854 00004654 90 03 00 00 */ stw r0, 0(r3) -/* 80007858 00004658 48 00 00 38 */ b lbl_80007890 -lbl_8000785C: -/* 8000785C 0000465C 7C 7F 1B 78 */ mr r31, r3 -/* 80007860 00004660 48 00 00 0C */ b lbl_8000786C -lbl_80007864: -/* 80007864 00004664 3B FF 00 08 */ addi r31, r31, 8 -/* 80007868 00004668 38 84 00 01 */ addi r4, r4, 1 -lbl_8000786C: -/* 8000786C 0000466C 7C 04 28 40 */ cmplw r4, r5 -/* 80007870 00004670 40 80 00 10 */ bge lbl_80007880 -/* 80007874 00004674 80 1F 00 08 */ lwz r0, 8(r31) -/* 80007878 00004678 28 00 00 00 */ cmplwi r0, 0 -/* 8000787C 0000467C 40 82 FF E8 */ bne lbl_80007864 -lbl_80007880: -/* 80007880 00004680 7F E4 FB 78 */ mr r4, r31 -/* 80007884 00004684 4B FF FF 91 */ bl __as__17xAnimActiveEffectFRC17xAnimActiveEffect -/* 80007888 00004688 38 00 00 00 */ li r0, 0 -/* 8000788C 0000468C 90 1F 00 00 */ stw r0, 0(r31) -lbl_80007890: -/* 80007890 00004690 80 01 00 14 */ lwz r0, 0x14(r1) -/* 80007894 00004694 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 80007898 00004698 7C 08 03 A6 */ mtlr r0 -/* 8000789C 0000469C 38 21 00 10 */ addi r1, r1, 0x10 -/* 800078A0 000046A0 4E 80 00 20 */ blr - -EffectPlaying__FP11xAnimSingleP11xAnimEffect: -/* 800078A4 000046A4 80 03 00 1C */ lwz r0, 0x1c(r3) -/* 800078A8 000046A8 38 E0 00 00 */ li r7, 0 -/* 800078AC 000046AC 38 C0 00 00 */ li r6, 0 -/* 800078B0 000046B0 48 00 00 1C */ b lbl_800078CC -lbl_800078B4: -/* 800078B4 000046B4 7C 05 20 40 */ cmplw r5, r4 -/* 800078B8 000046B8 40 82 00 0C */ bne lbl_800078C4 -/* 800078BC 000046BC 38 60 00 01 */ li r3, 1 -/* 800078C0 000046C0 4E 80 00 20 */ blr -lbl_800078C4: -/* 800078C4 000046C4 38 C6 00 08 */ addi r6, r6, 8 -/* 800078C8 000046C8 38 E7 00 01 */ addi r7, r7, 1 -lbl_800078CC: -/* 800078CC 000046CC 7C 07 00 40 */ cmplw r7, r0 -/* 800078D0 000046D0 40 80 00 14 */ bge lbl_800078E4 -/* 800078D4 000046D4 80 A3 00 24 */ lwz r5, 0x24(r3) -/* 800078D8 000046D8 7C A5 30 2E */ lwzx r5, r5, r6 -/* 800078DC 000046DC 28 05 00 00 */ cmplwi r5, 0 -/* 800078E0 000046E0 40 82 FF D4 */ bne lbl_800078B4 -lbl_800078E4: -/* 800078E4 000046E4 38 60 00 00 */ li r3, 0 -/* 800078E8 000046E8 4E 80 00 20 */ blr - -EffectSingleStart__FP11xAnimSingle: -/* 800078EC 000046EC 94 21 FF D0 */ stwu r1, -0x30(r1) -/* 800078F0 000046F0 7C 08 02 A6 */ mflr r0 -/* 800078F4 000046F4 90 01 00 34 */ stw r0, 0x34(r1) -/* 800078F8 000046F8 DB E1 00 20 */ stfd f31, 0x20(r1) -/* 800078FC 000046FC F3 E1 00 28 */ psq_st f31, 40(r1), 0, qr0 -/* 80007900 00004700 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80007904 00004704 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80007908 00004708 7C 7E 1B 78 */ mr r30, r3 -/* 8000790C 0000470C 80 63 00 04 */ lwz r3, 4(r3) -/* 80007910 00004710 C3 FE 00 08 */ lfs f31, 8(r30) -/* 80007914 00004714 83 E3 00 1C */ lwz r31, 0x1c(r3) -/* 80007918 00004718 48 00 00 FC */ b lbl_80007A14 -lbl_8000791C: -/* 8000791C 0000471C 80 7F 00 04 */ lwz r3, 4(r31) -/* 80007920 00004720 54 60 07 FF */ clrlwi. r0, r3, 0x1f -/* 80007924 00004724 41 82 00 EC */ beq lbl_80007A10 -/* 80007928 00004728 54 60 07 7B */ rlwinm. r0, r3, 0, 0x1d, 0x1d -/* 8000792C 0000472C 41 82 00 94 */ beq lbl_800079C0 -/* 80007930 00004730 93 E1 00 08 */ stw r31, 8(r1) -/* 80007934 00004734 7F C5 F3 78 */ mr r5, r30 -/* 80007938 00004738 38 81 00 08 */ addi r4, r1, 8 -/* 8000793C 0000473C 38 60 00 01 */ li r3, 1 -/* 80007940 00004740 80 DE 00 28 */ lwz r6, 0x28(r30) -/* 80007944 00004744 81 9F 00 10 */ lwz r12, 0x10(r31) -/* 80007948 00004748 80 C6 00 0C */ lwz r6, 0xc(r6) -/* 8000794C 0000474C 7D 89 03 A6 */ mtctr r12 -/* 80007950 00004750 4E 80 04 21 */ bctrl -/* 80007954 00004754 90 61 00 0C */ stw r3, 0xc(r1) -/* 80007958 00004758 80 7F 00 04 */ lwz r3, 4(r31) -/* 8000795C 0000475C 54 60 07 BD */ rlwinm. r0, r3, 0, 0x1e, 0x1e -/* 80007960 00004760 41 82 00 48 */ beq lbl_800079A8 -/* 80007964 00004764 C0 1F 00 0C */ lfs f0, 0xc(r31) -/* 80007968 00004768 FC 00 F8 40 */ fcmpo cr0, f0, f31 -/* 8000796C 0000476C 4C 40 13 82 */ cror 2, 0, 2 -/* 80007970 00004770 40 82 00 28 */ bne lbl_80007998 -/* 80007974 00004774 80 7E 00 28 */ lwz r3, 0x28(r30) -/* 80007978 00004778 7F C5 F3 78 */ mr r5, r30 -/* 8000797C 0000477C 81 9F 00 10 */ lwz r12, 0x10(r31) -/* 80007980 00004780 38 81 00 08 */ addi r4, r1, 8 -/* 80007984 00004784 80 C3 00 0C */ lwz r6, 0xc(r3) -/* 80007988 00004788 38 60 00 03 */ li r3, 3 -/* 8000798C 0000478C 7D 89 03 A6 */ mtctr r12 -/* 80007990 00004790 4E 80 04 21 */ bctrl -/* 80007994 00004794 48 00 00 7C */ b lbl_80007A10 -lbl_80007998: -/* 80007998 00004798 7F C3 F3 78 */ mr r3, r30 -/* 8000799C 0000479C 38 81 00 08 */ addi r4, r1, 8 -/* 800079A0 000047A0 4B FF FD F9 */ bl EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect -/* 800079A4 000047A4 48 00 00 6C */ b lbl_80007A10 -lbl_800079A8: -/* 800079A8 000047A8 54 60 06 B5 */ rlwinm. r0, r3, 0, 0x1a, 0x1a -/* 800079AC 000047AC 41 82 00 64 */ beq lbl_80007A10 -/* 800079B0 000047B0 7F C3 F3 78 */ mr r3, r30 -/* 800079B4 000047B4 38 81 00 08 */ addi r4, r1, 8 -/* 800079B8 000047B8 4B FF FD E1 */ bl EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect -/* 800079BC 000047BC 48 00 00 54 */ b lbl_80007A10 -lbl_800079C0: -/* 800079C0 000047C0 54 60 07 BD */ rlwinm. r0, r3, 0, 0x1e, 0x1e -/* 800079C4 000047C4 41 82 00 4C */ beq lbl_80007A10 -/* 800079C8 000047C8 54 60 06 F7 */ rlwinm. r0, r3, 0, 0x1b, 0x1b -/* 800079CC 000047CC 40 82 00 44 */ bne lbl_80007A10 -/* 800079D0 000047D0 C0 1F 00 0C */ lfs f0, 0xc(r31) -/* 800079D4 000047D4 FC 00 F8 40 */ fcmpo cr0, f0, f31 -/* 800079D8 000047D8 40 81 00 38 */ ble lbl_80007A10 -/* 800079DC 000047DC 93 E1 00 08 */ stw r31, 8(r1) -/* 800079E0 000047E0 7F C5 F3 78 */ mr r5, r30 -/* 800079E4 000047E4 38 81 00 08 */ addi r4, r1, 8 -/* 800079E8 000047E8 38 60 00 01 */ li r3, 1 -/* 800079EC 000047EC 80 DE 00 28 */ lwz r6, 0x28(r30) -/* 800079F0 000047F0 81 9F 00 10 */ lwz r12, 0x10(r31) -/* 800079F4 000047F4 80 C6 00 0C */ lwz r6, 0xc(r6) -/* 800079F8 000047F8 7D 89 03 A6 */ mtctr r12 -/* 800079FC 000047FC 4E 80 04 21 */ bctrl -/* 80007A00 00004800 90 61 00 0C */ stw r3, 0xc(r1) -/* 80007A04 00004804 7F C3 F3 78 */ mr r3, r30 -/* 80007A08 00004808 38 81 00 08 */ addi r4, r1, 8 -/* 80007A0C 0000480C 4B FF FD 8D */ bl EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect -lbl_80007A10: -/* 80007A10 00004810 83 FF 00 00 */ lwz r31, 0(r31) -lbl_80007A14: -/* 80007A14 00004814 28 1F 00 00 */ cmplwi r31, 0 -/* 80007A18 00004818 41 82 00 10 */ beq lbl_80007A28 -/* 80007A1C 0000481C C0 1F 00 08 */ lfs f0, 8(r31) -/* 80007A20 00004820 FC 00 F8 40 */ fcmpo cr0, f0, f31 -/* 80007A24 00004824 41 80 FE F8 */ blt lbl_8000791C -lbl_80007A28: -/* 80007A28 00004828 93 FE 00 18 */ stw r31, 0x18(r30) -/* 80007A2C 0000482C E3 E1 00 28 */ psq_l f31, 40(r1), 0, qr0 -/* 80007A30 00004830 80 01 00 34 */ lwz r0, 0x34(r1) -/* 80007A34 00004834 CB E1 00 20 */ lfd f31, 0x20(r1) -/* 80007A38 00004838 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80007A3C 0000483C 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80007A40 00004840 7C 08 03 A6 */ mtlr r0 -/* 80007A44 00004844 38 21 00 30 */ addi r1, r1, 0x30 -/* 80007A48 00004848 4E 80 00 20 */ blr - -EffectSingleDuration__FP11xAnimSingle: -/* 80007A4C 0000484C 94 21 FF D0 */ stwu r1, -0x30(r1) -/* 80007A50 00004850 7C 08 02 A6 */ mflr r0 -/* 80007A54 00004854 90 01 00 34 */ stw r0, 0x34(r1) -/* 80007A58 00004858 DB E1 00 20 */ stfd f31, 0x20(r1) -/* 80007A5C 0000485C F3 E1 00 28 */ psq_st f31, 40(r1), 0, qr0 -/* 80007A60 00004860 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80007A64 00004864 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80007A68 00004868 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80007A6C 0000486C 93 81 00 10 */ stw r28, 0x10(r1) -/* 80007A70 00004870 7C 7C 1B 78 */ mr r28, r3 -/* 80007A74 00004874 3B C0 00 00 */ li r30, 0 -/* 80007A78 00004878 C3 E3 00 08 */ lfs f31, 8(r3) -/* 80007A7C 0000487C 83 E3 00 24 */ lwz r31, 0x24(r3) -/* 80007A80 00004880 83 A3 00 1C */ lwz r29, 0x1c(r3) -/* 80007A84 00004884 48 00 00 7C */ b lbl_80007B00 -lbl_80007A88: -/* 80007A88 00004888 80 05 00 04 */ lwz r0, 4(r5) -/* 80007A8C 0000488C 54 00 06 B5 */ rlwinm. r0, r0, 0, 0x1a, 0x1a -/* 80007A90 00004890 40 82 00 48 */ bne lbl_80007AD8 -/* 80007A94 00004894 C0 05 00 0C */ lfs f0, 0xc(r5) -/* 80007A98 00004898 FC 00 F8 40 */ fcmpo cr0, f0, f31 -/* 80007A9C 0000489C 4C 40 13 82 */ cror 2, 0, 2 -/* 80007AA0 000048A0 40 82 00 38 */ bne lbl_80007AD8 -/* 80007AA4 000048A4 80 7C 00 28 */ lwz r3, 0x28(r28) -/* 80007AA8 000048A8 7F E4 FB 78 */ mr r4, r31 -/* 80007AAC 000048AC 81 85 00 10 */ lwz r12, 0x10(r5) -/* 80007AB0 000048B0 7F 85 E3 78 */ mr r5, r28 -/* 80007AB4 000048B4 80 C3 00 0C */ lwz r6, 0xc(r3) -/* 80007AB8 000048B8 38 60 00 03 */ li r3, 3 -/* 80007ABC 000048BC 7D 89 03 A6 */ mtctr r12 -/* 80007AC0 000048C0 4E 80 04 21 */ bctrl -/* 80007AC4 000048C4 7F E3 FB 78 */ mr r3, r31 -/* 80007AC8 000048C8 7F C4 F3 78 */ mr r4, r30 -/* 80007ACC 000048CC 7F A5 EB 78 */ mr r5, r29 -/* 80007AD0 000048D0 4B FF FD 59 */ bl EffectActiveRemove__FP17xAnimActiveEffectUiUi -/* 80007AD4 000048D4 48 00 00 2C */ b lbl_80007B00 -lbl_80007AD8: -/* 80007AD8 000048D8 80 7C 00 28 */ lwz r3, 0x28(r28) -/* 80007ADC 000048DC 7F E4 FB 78 */ mr r4, r31 -/* 80007AE0 000048E0 81 85 00 10 */ lwz r12, 0x10(r5) -/* 80007AE4 000048E4 7F 85 E3 78 */ mr r5, r28 -/* 80007AE8 000048E8 80 C3 00 0C */ lwz r6, 0xc(r3) -/* 80007AEC 000048EC 38 60 00 02 */ li r3, 2 -/* 80007AF0 000048F0 7D 89 03 A6 */ mtctr r12 -/* 80007AF4 000048F4 4E 80 04 21 */ bctrl -/* 80007AF8 000048F8 3B FF 00 08 */ addi r31, r31, 8 -/* 80007AFC 000048FC 3B DE 00 01 */ addi r30, r30, 1 -lbl_80007B00: -/* 80007B00 00004900 7C 1E E8 40 */ cmplw r30, r29 -/* 80007B04 00004904 40 80 00 10 */ bge lbl_80007B14 -/* 80007B08 00004908 80 BF 00 00 */ lwz r5, 0(r31) -/* 80007B0C 0000490C 28 05 00 00 */ cmplwi r5, 0 -/* 80007B10 00004910 40 82 FF 78 */ bne lbl_80007A88 -lbl_80007B14: -/* 80007B14 00004914 E3 E1 00 28 */ psq_l f31, 40(r1), 0, qr0 -/* 80007B18 00004918 80 01 00 34 */ lwz r0, 0x34(r1) -/* 80007B1C 0000491C CB E1 00 20 */ lfd f31, 0x20(r1) -/* 80007B20 00004920 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80007B24 00004924 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80007B28 00004928 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80007B2C 0000492C 83 81 00 10 */ lwz r28, 0x10(r1) -/* 80007B30 00004930 7C 08 03 A6 */ mtlr r0 -/* 80007B34 00004934 38 21 00 30 */ addi r1, r1, 0x30 -/* 80007B38 00004938 4E 80 00 20 */ blr - -EffectSingleRun__FP11xAnimSingle: -/* 80007B3C 0000493C 94 21 FF D0 */ stwu r1, -0x30(r1) -/* 80007B40 00004940 7C 08 02 A6 */ mflr r0 -/* 80007B44 00004944 90 01 00 34 */ stw r0, 0x34(r1) -/* 80007B48 00004948 DB E1 00 20 */ stfd f31, 0x20(r1) -/* 80007B4C 0000494C F3 E1 00 28 */ psq_st f31, 40(r1), 0, qr0 -/* 80007B50 00004950 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80007B54 00004954 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80007B58 00004958 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80007B5C 0000495C 93 81 00 10 */ stw r28, 0x10(r1) -/* 80007B60 00004960 7C 7C 1B 78 */ mr r28, r3 -/* 80007B64 00004964 83 C3 00 18 */ lwz r30, 0x18(r3) -/* 80007B68 00004968 C3 E3 00 08 */ lfs f31, 8(r3) -/* 80007B6C 0000496C 48 00 00 B8 */ b lbl_80007C24 -lbl_80007B70: -/* 80007B70 00004970 83 BE 00 04 */ lwz r29, 4(r30) -/* 80007B74 00004974 57 A0 07 FF */ clrlwi. r0, r29, 0x1f -/* 80007B78 00004978 41 82 00 A8 */ beq lbl_80007C20 -/* 80007B7C 0000497C 57 BF 06 B5 */ rlwinm. r31, r29, 0, 0x1a, 0x1a -/* 80007B80 00004980 41 82 00 18 */ beq lbl_80007B98 -/* 80007B84 00004984 7F 83 E3 78 */ mr r3, r28 -/* 80007B88 00004988 7F C4 F3 78 */ mr r4, r30 -/* 80007B8C 0000498C 4B FF FD 19 */ bl EffectPlaying__FP11xAnimSingleP11xAnimEffect -/* 80007B90 00004990 28 03 00 00 */ cmplwi r3, 0 -/* 80007B94 00004994 40 82 00 8C */ bne lbl_80007C20 -lbl_80007B98: -/* 80007B98 00004998 93 C1 00 08 */ stw r30, 8(r1) -/* 80007B9C 0000499C 7F 85 E3 78 */ mr r5, r28 -/* 80007BA0 000049A0 38 81 00 08 */ addi r4, r1, 8 -/* 80007BA4 000049A4 38 60 00 01 */ li r3, 1 -/* 80007BA8 000049A8 80 DC 00 28 */ lwz r6, 0x28(r28) -/* 80007BAC 000049AC 81 9E 00 10 */ lwz r12, 0x10(r30) -/* 80007BB0 000049B0 80 C6 00 0C */ lwz r6, 0xc(r6) -/* 80007BB4 000049B4 7D 89 03 A6 */ mtctr r12 -/* 80007BB8 000049B8 4E 80 04 21 */ bctrl -/* 80007BBC 000049BC 57 A0 07 BD */ rlwinm. r0, r29, 0, 0x1e, 0x1e -/* 80007BC0 000049C0 90 61 00 0C */ stw r3, 0xc(r1) -/* 80007BC4 000049C4 41 82 00 48 */ beq lbl_80007C0C -/* 80007BC8 000049C8 C0 1E 00 0C */ lfs f0, 0xc(r30) -/* 80007BCC 000049CC FC 00 F8 40 */ fcmpo cr0, f0, f31 -/* 80007BD0 000049D0 4C 40 13 82 */ cror 2, 0, 2 -/* 80007BD4 000049D4 40 82 00 28 */ bne lbl_80007BFC -/* 80007BD8 000049D8 80 7C 00 28 */ lwz r3, 0x28(r28) -/* 80007BDC 000049DC 7F 85 E3 78 */ mr r5, r28 -/* 80007BE0 000049E0 81 9E 00 10 */ lwz r12, 0x10(r30) -/* 80007BE4 000049E4 38 81 00 08 */ addi r4, r1, 8 -/* 80007BE8 000049E8 80 C3 00 0C */ lwz r6, 0xc(r3) -/* 80007BEC 000049EC 38 60 00 03 */ li r3, 3 -/* 80007BF0 000049F0 7D 89 03 A6 */ mtctr r12 -/* 80007BF4 000049F4 4E 80 04 21 */ bctrl -/* 80007BF8 000049F8 48 00 00 28 */ b lbl_80007C20 -lbl_80007BFC: -/* 80007BFC 000049FC 7F 83 E3 78 */ mr r3, r28 -/* 80007C00 00004A00 38 81 00 08 */ addi r4, r1, 8 -/* 80007C04 00004A04 4B FF FB 95 */ bl EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect -/* 80007C08 00004A08 48 00 00 18 */ b lbl_80007C20 -lbl_80007C0C: -/* 80007C0C 00004A0C 28 1F 00 00 */ cmplwi r31, 0 -/* 80007C10 00004A10 41 82 00 10 */ beq lbl_80007C20 -/* 80007C14 00004A14 7F 83 E3 78 */ mr r3, r28 -/* 80007C18 00004A18 38 81 00 08 */ addi r4, r1, 8 -/* 80007C1C 00004A1C 4B FF FB 7D */ bl EffectActiveInsert__FP11xAnimSingleP17xAnimActiveEffect -lbl_80007C20: -/* 80007C20 00004A20 83 DE 00 00 */ lwz r30, 0(r30) -lbl_80007C24: -/* 80007C24 00004A24 28 1E 00 00 */ cmplwi r30, 0 -/* 80007C28 00004A28 41 82 00 14 */ beq lbl_80007C3C -/* 80007C2C 00004A2C C0 1E 00 08 */ lfs f0, 8(r30) -/* 80007C30 00004A30 FC 00 F8 40 */ fcmpo cr0, f0, f31 -/* 80007C34 00004A34 4C 40 13 82 */ cror 2, 0, 2 -/* 80007C38 00004A38 41 82 FF 38 */ beq lbl_80007B70 -lbl_80007C3C: -/* 80007C3C 00004A3C 93 DC 00 18 */ stw r30, 0x18(r28) -/* 80007C40 00004A40 E3 E1 00 28 */ psq_l f31, 40(r1), 0, qr0 -/* 80007C44 00004A44 80 01 00 34 */ lwz r0, 0x34(r1) -/* 80007C48 00004A48 CB E1 00 20 */ lfd f31, 0x20(r1) -/* 80007C4C 00004A4C 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 80007C50 00004A50 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80007C54 00004A54 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80007C58 00004A58 83 81 00 10 */ lwz r28, 0x10(r1) -/* 80007C5C 00004A5C 7C 08 03 A6 */ mtlr r0 -/* 80007C60 00004A60 38 21 00 30 */ addi r1, r1, 0x30 -/* 80007C64 00004A64 4E 80 00 20 */ blr - EffectSingleLoop__FP11xAnimSingle: /* 80007C68 00004A68 94 21 FF E0 */ stwu r1, -0x20(r1) /* 80007C6C 00004A6C 7C 08 02 A6 */ mflr r0 @@ -2814,37 +1883,6 @@ StopUpdate__FP11xAnimSingle: /* 80007EA4 00004CA4 D0 03 00 0C */ stfs f0, 0xc(r3) /* 80007EA8 00004CA8 4E 80 00 20 */ blr -LoopUpdate__FP11xAnimSingle: -/* 80007EAC 00004CAC 94 21 FF D0 */ stwu r1, -0x30(r1) -/* 80007EB0 00004CB0 7C 08 02 A6 */ mflr r0 -/* 80007EB4 00004CB4 90 01 00 34 */ stw r0, 0x34(r1) -/* 80007EB8 00004CB8 DB E1 00 20 */ stfd f31, 0x20(r1) -/* 80007EBC 00004CBC F3 E1 00 28 */ psq_st f31, 40(r1), 0, qr0 -/* 80007EC0 00004CC0 DB C1 00 10 */ stfd f30, 0x10(r1) -/* 80007EC4 00004CC4 F3 C1 00 18 */ psq_st f30, 24(r1), 0, qr0 -/* 80007EC8 00004CC8 93 E1 00 0C */ stw r31, 0xc(r1) -/* 80007ECC 00004CCC 7C 7F 1B 78 */ mr r31, r3 -/* 80007ED0 00004CD0 80 83 00 04 */ lwz r4, 4(r3) -/* 80007ED4 00004CD4 C3 E3 00 08 */ lfs f31, 8(r3) -/* 80007ED8 00004CD8 80 84 00 18 */ lwz r4, 0x18(r4) -/* 80007EDC 00004CDC C3 C4 00 10 */ lfs f30, 0x10(r4) -/* 80007EE0 00004CE0 FC 1F F0 40 */ fcmpo cr0, f31, f30 -/* 80007EE4 00004CE4 40 81 00 14 */ ble lbl_80007EF8 -/* 80007EE8 00004CE8 D3 DF 00 08 */ stfs f30, 8(r31) -/* 80007EEC 00004CEC 4B FF FD 7D */ bl EffectSingleLoop__FP11xAnimSingle -/* 80007EF0 00004CF0 EC 1F F0 28 */ fsubs f0, f31, f30 -/* 80007EF4 00004CF4 D0 1F 00 08 */ stfs f0, 8(r31) -lbl_80007EF8: -/* 80007EF8 00004CF8 E3 E1 00 28 */ psq_l f31, 40(r1), 0, qr0 -/* 80007EFC 00004CFC CB E1 00 20 */ lfd f31, 0x20(r1) -/* 80007F00 00004D00 E3 C1 00 18 */ psq_l f30, 24(r1), 0, qr0 -/* 80007F04 00004D04 CB C1 00 10 */ lfd f30, 0x10(r1) -/* 80007F08 00004D08 80 01 00 34 */ lwz r0, 0x34(r1) -/* 80007F0C 00004D0C 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 80007F10 00004D10 7C 08 03 A6 */ mtlr r0 -/* 80007F14 00004D14 38 21 00 30 */ addi r1, r1, 0x30 -/* 80007F18 00004D18 4E 80 00 20 */ blr - .global xAnimPlaySetState__FP11xAnimSingleP10xAnimStatef xAnimPlaySetState__FP11xAnimSingleP10xAnimStatef: /* 80007F1C 00004D1C 94 21 FF E0 */ stwu r1, -0x20(r1) @@ -3415,66 +2453,6 @@ lbl_800086E4: /* 80008720 00005520 38 21 00 90 */ addi r1, r1, 0x90 /* 80008724 00005524 4E 80 00 20 */ blr -SingleEval__FP11xAnimSingleP5xVec3P5xQuat: -/* 80008728 00005528 94 21 FF D0 */ stwu r1, -0x30(r1) -/* 8000872C 0000552C 7C 08 02 A6 */ mflr r0 -/* 80008730 00005530 90 01 00 34 */ stw r0, 0x34(r1) -/* 80008734 00005534 BF 61 00 1C */ stmw r27, 0x1c(r1) -/* 80008738 00005538 7C 7B 1B 78 */ mr r27, r3 -/* 8000873C 0000553C 7C 9C 23 78 */ mr r28, r4 -/* 80008740 00005540 7C BD 2B 78 */ mr r29, r5 -/* 80008744 00005544 80 63 00 28 */ lwz r3, 0x28(r3) -/* 80008748 00005548 A0 03 00 06 */ lhz r0, 6(r3) -/* 8000874C 0000554C 28 00 00 01 */ cmplwi r0, 1 -/* 80008750 00005550 40 81 00 A8 */ ble lbl_800087F8 -/* 80008754 00005554 80 7B 00 04 */ lwz r3, 4(r27) -/* 80008758 00005558 38 9B 00 10 */ addi r4, r27, 0x10 -/* 8000875C 0000555C C0 3B 00 08 */ lfs f1, 8(r27) -/* 80008760 00005560 38 DC 00 0C */ addi r6, r28, 0xc -/* 80008764 00005564 80 63 00 18 */ lwz r3, 0x18(r3) -/* 80008768 00005568 38 FD 00 10 */ addi r7, r29, 0x10 -/* 8000876C 0000556C 38 A0 00 02 */ li r5, 2 -/* 80008770 00005570 39 00 00 00 */ li r8, 0 -/* 80008774 00005574 4B FF DE E5 */ bl xAnimFileEval__FP9xAnimFilefPfUiP5xVec3P5xQuatPf -/* 80008778 00005578 80 FB 00 34 */ lwz r7, 0x34(r27) -/* 8000877C 0000557C 28 07 00 00 */ cmplwi r7, 0 -/* 80008780 00005580 41 82 00 78 */ beq lbl_800087F8 -/* 80008784 00005584 80 67 00 04 */ lwz r3, 4(r7) -/* 80008788 00005588 28 03 00 00 */ cmplwi r3, 0 -/* 8000878C 0000558C 41 82 00 6C */ beq lbl_800087F8 -/* 80008790 00005590 80 CD 83 30 */ lwz r6, giAnimScratch-_SDA_BASE_(r13) -/* 80008794 00005594 38 87 00 10 */ addi r4, r7, 0x10 -/* 80008798 00005598 80 63 00 18 */ lwz r3, 0x18(r3) -/* 8000879C 0000559C 38 A0 00 02 */ li r5, 2 -/* 800087A0 000055A0 3B E6 0E 40 */ addi r31, r6, 0xe40 -/* 800087A4 000055A4 C0 27 00 08 */ lfs f1, 8(r7) -/* 800087A8 000055A8 3B DF 04 10 */ addi r30, r31, 0x410 -/* 800087AC 000055AC 39 00 00 00 */ li r8, 0 -/* 800087B0 000055B0 7F C6 F3 78 */ mr r6, r30 -/* 800087B4 000055B4 7F E7 FB 78 */ mr r7, r31 -/* 800087B8 000055B8 4B FF DE A1 */ bl xAnimFileEval__FP9xAnimFilefPfUiP5xVec3P5xQuatPf -/* 800087BC 000055BC 81 7B 00 30 */ lwz r11, 0x30(r27) -/* 800087C0 000055C0 39 3D 00 10 */ addi r9, r29, 0x10 -/* 800087C4 000055C4 39 1C 00 0C */ addi r8, r28, 0xc -/* 800087C8 000055C8 7F C6 F3 78 */ mr r6, r30 -/* 800087CC 000055CC 91 21 00 08 */ stw r9, 8(r1) -/* 800087D0 000055D0 7F E7 FB 78 */ mr r7, r31 -/* 800087D4 000055D4 7D 0A 43 78 */ mr r10, r8 -/* 800087D8 000055D8 38 80 00 00 */ li r4, 0 -/* 800087DC 000055DC 80 7B 00 28 */ lwz r3, 0x28(r27) -/* 800087E0 000055E0 C0 3B 00 38 */ lfs f1, 0x38(r27) -/* 800087E4 000055E4 A0 A3 00 06 */ lhz r5, 6(r3) -/* 800087E8 000055E8 C0 4B 00 24 */ lfs f2, 0x24(r11) -/* 800087EC 000055EC 80 6B 00 28 */ lwz r3, 0x28(r11) -/* 800087F0 000055F0 38 A5 FF FF */ addi r5, r5, -1 -/* 800087F4 000055F4 48 0B 62 65 */ bl iAnimBlend__FffPUsPfUiP5xVec3P5xQuatP5xVec3P5xQuatP5xVec3P5xQuat -lbl_800087F8: -/* 800087F8 000055F8 BB 61 00 1C */ lmw r27, 0x1c(r1) -/* 800087FC 000055FC 80 01 00 34 */ lwz r0, 0x34(r1) -/* 80008800 00005600 7C 08 03 A6 */ mtlr r0 -/* 80008804 00005604 38 21 00 30 */ addi r1, r1, 0x30 -/* 80008808 00005608 4E 80 00 20 */ blr - .global xAnimPlaySetup__FP9xAnimPlayPvP10xAnimTableP14xModelInstance xAnimPlaySetup__FP9xAnimPlayPvP10xAnimTableP14xModelInstance: /* 8000880C 0000560C 94 21 FF F0 */ stwu r1, -0x10(r1) @@ -3539,106 +2517,6 @@ lbl_800088C0: /* 800088E4 000056E4 38 21 00 10 */ addi r1, r1, 0x10 /* 800088E8 000056E8 4E 80 00 20 */ blr -.global xAnimPlayChooseTransition__FP9xAnimPlay -xAnimPlayChooseTransition__FP9xAnimPlay: -/* 800088EC 000056EC 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 800088F0 000056F0 7C 08 02 A6 */ mflr r0 -/* 800088F4 000056F4 38 80 00 00 */ li r4, 0 -/* 800088F8 000056F8 90 01 00 24 */ stw r0, 0x24(r1) -/* 800088FC 000056FC BF 41 00 08 */ stmw r26, 8(r1) -/* 80008900 00005700 7C 7C 1B 78 */ mr r28, r3 -/* 80008904 00005704 A0 03 00 04 */ lhz r0, 4(r3) -/* 80008908 00005708 83 AD 83 30 */ lwz r29, giAnimScratch-_SDA_BASE_(r13) -/* 8000890C 0000570C 83 C3 00 0C */ lwz r30, 0xc(r3) -/* 80008910 00005710 54 05 10 3A */ slwi r5, r0, 2 -/* 80008914 00005714 7F A3 EB 78 */ mr r3, r29 -/* 80008918 00005718 4B FF AB 41 */ bl memset -/* 8000891C 0000571C 3B E0 00 00 */ li r31, 0 -/* 80008920 00005720 3B 60 00 00 */ li r27, 0 -/* 80008924 00005724 48 00 00 A0 */ b lbl_800089C4 -lbl_80008928: -/* 80008928 00005728 80 7C 00 08 */ lwz r3, 8(r28) -/* 8000892C 0000572C 38 1B 00 04 */ addi r0, r27, 4 -/* 80008930 00005730 7C 63 00 2E */ lwzx r3, r3, r0 -/* 80008934 00005734 28 03 00 00 */ cmplwi r3, 0 -/* 80008938 00005738 41 82 00 84 */ beq lbl_800089BC -/* 8000893C 0000573C 83 43 00 24 */ lwz r26, 0x24(r3) -/* 80008940 00005740 28 1A 00 00 */ cmplwi r26, 0 -/* 80008944 00005744 41 82 00 78 */ beq lbl_800089BC -/* 80008948 00005748 80 7A 00 04 */ lwz r3, 4(r26) -/* 8000894C 0000574C 80 03 00 08 */ lwz r0, 8(r3) -/* 80008950 00005750 28 00 00 00 */ cmplwi r0, 0 -/* 80008954 00005754 41 82 00 68 */ beq lbl_800089BC -/* 80008958 00005758 48 00 00 5C */ b lbl_800089B4 -lbl_8000895C: -/* 8000895C 0000575C 80 7A 00 04 */ lwz r3, 4(r26) -/* 80008960 00005760 7F C5 F3 78 */ mr r5, r30 -/* 80008964 00005764 80 1C 00 08 */ lwz r0, 8(r28) -/* 80008968 00005768 81 83 00 08 */ lwz r12, 8(r3) -/* 8000896C 0000576C 7C 80 DA 14 */ add r4, r0, r27 -/* 80008970 00005770 7D 89 03 A6 */ mtctr r12 -/* 80008974 00005774 4E 80 04 21 */ bctrl -/* 80008978 00005778 28 03 00 00 */ cmplwi r3, 0 -/* 8000897C 0000577C 41 82 00 34 */ beq lbl_800089B0 -/* 80008980 00005780 80 DA 00 04 */ lwz r6, 4(r26) -/* 80008984 00005784 80 66 00 04 */ lwz r3, 4(r6) -/* 80008988 00005788 80 03 00 0C */ lwz r0, 0xc(r3) -/* 8000898C 0000578C 54 04 16 BA */ rlwinm r4, r0, 2, 0x1a, 0x1d -/* 80008990 00005790 7C BD 20 2E */ lwzx r5, r29, r4 -/* 80008994 00005794 28 05 00 00 */ cmplwi r5, 0 -/* 80008998 00005798 41 82 00 14 */ beq lbl_800089AC -/* 8000899C 0000579C A0 66 00 20 */ lhz r3, 0x20(r6) -/* 800089A0 000057A0 A0 05 00 20 */ lhz r0, 0x20(r5) -/* 800089A4 000057A4 7C 03 00 40 */ cmplw r3, r0 -/* 800089A8 000057A8 40 81 00 08 */ ble lbl_800089B0 -lbl_800089AC: -/* 800089AC 000057AC 7C DD 21 2E */ stwx r6, r29, r4 -lbl_800089B0: -/* 800089B0 000057B0 83 5A 00 00 */ lwz r26, 0(r26) -lbl_800089B4: -/* 800089B4 000057B4 28 1A 00 00 */ cmplwi r26, 0 -/* 800089B8 000057B8 40 82 FF A4 */ bne lbl_8000895C -lbl_800089BC: -/* 800089BC 000057BC 3B 7B 00 40 */ addi r27, r27, 0x40 -/* 800089C0 000057C0 3B FF 00 01 */ addi r31, r31, 1 -lbl_800089C4: -/* 800089C4 000057C4 A0 1C 00 04 */ lhz r0, 4(r28) -/* 800089C8 000057C8 7C 1F 00 40 */ cmplw r31, r0 -/* 800089CC 000057CC 41 80 FF 5C */ blt lbl_80008928 -/* 800089D0 000057D0 3B C0 00 00 */ li r30, 0 -/* 800089D4 000057D4 7F BB EB 78 */ mr r27, r29 -/* 800089D8 000057D8 7F DD F3 78 */ mr r29, r30 -/* 800089DC 000057DC 48 00 00 48 */ b lbl_80008A24 -lbl_800089E0: -/* 800089E0 000057E0 80 9B 00 00 */ lwz r4, 0(r27) -/* 800089E4 000057E4 28 04 00 00 */ cmplwi r4, 0 -/* 800089E8 000057E8 41 82 00 30 */ beq lbl_80008A18 -/* 800089EC 000057EC 80 7C 00 08 */ lwz r3, 8(r28) -/* 800089F0 000057F0 38 1D 00 2C */ addi r0, r29, 0x2c -/* 800089F4 000057F4 7C A3 00 2E */ lwzx r5, r3, r0 -/* 800089F8 000057F8 28 05 00 00 */ cmplwi r5, 0 -/* 800089FC 000057FC 41 82 00 14 */ beq lbl_80008A10 -/* 80008A00 00005800 A0 64 00 20 */ lhz r3, 0x20(r4) -/* 80008A04 00005804 A0 05 00 22 */ lhz r0, 0x22(r5) -/* 80008A08 00005808 7C 03 00 40 */ cmplw r3, r0 -/* 80008A0C 0000580C 40 81 00 0C */ ble lbl_80008A18 -lbl_80008A10: -/* 80008A10 00005810 7F 83 E3 78 */ mr r3, r28 -/* 80008A14 00005814 48 00 00 31 */ bl xAnimPlayStartTransition__FP9xAnimPlayP15xAnimTransition -lbl_80008A18: -/* 80008A18 00005818 3B 7B 00 04 */ addi r27, r27, 4 -/* 80008A1C 0000581C 3B BD 00 40 */ addi r29, r29, 0x40 -/* 80008A20 00005820 3B DE 00 01 */ addi r30, r30, 1 -lbl_80008A24: -/* 80008A24 00005824 A0 1C 00 04 */ lhz r0, 4(r28) -/* 80008A28 00005828 7C 1E 00 40 */ cmplw r30, r0 -/* 80008A2C 0000582C 41 80 FF B4 */ blt lbl_800089E0 -/* 80008A30 00005830 BB 41 00 08 */ lmw r26, 8(r1) -/* 80008A34 00005834 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80008A38 00005838 7C 08 03 A6 */ mtlr r0 -/* 80008A3C 0000583C 38 21 00 20 */ addi r1, r1, 0x20 -/* 80008A40 00005840 4E 80 00 20 */ blr - .global xAnimPlayStartTransition__FP9xAnimPlayP15xAnimTransition xAnimPlayStartTransition__FP9xAnimPlayP15xAnimTransition: /* 80008A44 00005844 94 21 FF E0 */ stwu r1, -0x20(r1) @@ -3790,52 +2668,6 @@ lbl_80008C48: /* 80008C60 00005A60 38 21 00 20 */ addi r1, r1, 0x20 /* 80008C64 00005A64 4E 80 00 20 */ blr -.global xAnimPlayUpdate__FP9xAnimPlayf -xAnimPlayUpdate__FP9xAnimPlayf: -/* 80008C68 00005A68 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 80008C6C 00005A6C 7C 08 02 A6 */ mflr r0 -/* 80008C70 00005A70 90 01 00 24 */ stw r0, 0x24(r1) -/* 80008C74 00005A74 DB E1 00 18 */ stfd f31, 0x18(r1) -/* 80008C78 00005A78 FF E0 08 90 */ fmr f31, f1 -/* 80008C7C 00005A7C 93 E1 00 14 */ stw r31, 0x14(r1) -/* 80008C80 00005A80 3B E0 00 00 */ li r31, 0 -/* 80008C84 00005A84 93 C1 00 10 */ stw r30, 0x10(r1) -/* 80008C88 00005A88 3B C0 00 00 */ li r30, 0 -/* 80008C8C 00005A8C 93 A1 00 0C */ stw r29, 0xc(r1) -/* 80008C90 00005A90 93 81 00 08 */ stw r28, 8(r1) -/* 80008C94 00005A94 7C 7C 1B 78 */ mr r28, r3 -/* 80008C98 00005A98 48 00 00 40 */ b lbl_80008CD8 -lbl_80008C9C: -/* 80008C9C 00005A9C 80 1C 00 08 */ lwz r0, 8(r28) -/* 80008CA0 00005AA0 FC 20 F8 90 */ fmr f1, f31 -/* 80008CA4 00005AA4 7F A0 FA 14 */ add r29, r0, r31 -/* 80008CA8 00005AA8 7F A3 EB 78 */ mr r3, r29 -/* 80008CAC 00005AAC 4B FF F3 A1 */ bl SingleUpdate__FP11xAnimSinglef -/* 80008CB0 00005AB0 80 7D 00 04 */ lwz r3, 4(r29) -/* 80008CB4 00005AB4 81 83 00 44 */ lwz r12, 0x44(r3) -/* 80008CB8 00005AB8 28 0C 00 00 */ cmplwi r12, 0 -/* 80008CBC 00005ABC 41 82 00 14 */ beq lbl_80008CD0 -/* 80008CC0 00005AC0 7F A4 EB 78 */ mr r4, r29 -/* 80008CC4 00005AC4 80 BC 00 0C */ lwz r5, 0xc(r28) -/* 80008CC8 00005AC8 7D 89 03 A6 */ mtctr r12 -/* 80008CCC 00005ACC 4E 80 04 21 */ bctrl -lbl_80008CD0: -/* 80008CD0 00005AD0 3B FF 00 40 */ addi r31, r31, 0x40 -/* 80008CD4 00005AD4 3B DE 00 01 */ addi r30, r30, 1 -lbl_80008CD8: -/* 80008CD8 00005AD8 A0 1C 00 04 */ lhz r0, 4(r28) -/* 80008CDC 00005ADC 7C 1E 00 40 */ cmplw r30, r0 -/* 80008CE0 00005AE0 41 80 FF BC */ blt lbl_80008C9C -/* 80008CE4 00005AE4 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80008CE8 00005AE8 CB E1 00 18 */ lfd f31, 0x18(r1) -/* 80008CEC 00005AEC 83 E1 00 14 */ lwz r31, 0x14(r1) -/* 80008CF0 00005AF0 83 C1 00 10 */ lwz r30, 0x10(r1) -/* 80008CF4 00005AF4 83 A1 00 0C */ lwz r29, 0xc(r1) -/* 80008CF8 00005AF8 83 81 00 08 */ lwz r28, 8(r1) -/* 80008CFC 00005AFC 7C 08 03 A6 */ mtlr r0 -/* 80008D00 00005B00 38 21 00 20 */ addi r1, r1, 0x20 -/* 80008D04 00005B04 4E 80 00 20 */ blr - .global xAnimPlayEval__FP9xAnimPlay xAnimPlayEval__FP9xAnimPlay: /* 80008D08 00005B08 94 21 FF A0 */ stwu r1, -0x60(r1) @@ -4022,85 +2854,6 @@ lbl_80008F74: /* 80008FAC 00005DAC 38 21 00 60 */ addi r1, r1, 0x60 /* 80008FB0 00005DB0 4E 80 00 20 */ blr -.global xAnimPoolCB__FP8xMemPoolPv -xAnimPoolCB__FP8xMemPoolPv: -/* 80008FB4 00005DB4 80 A3 00 10 */ lwz r5, 0x10(r3) -/* 80008FB8 00005DB8 39 40 00 00 */ li r10, 0 -/* 80008FBC 00005DBC 39 84 00 20 */ addi r12, r4, 0x20 -/* 80008FC0 00005DC0 39 60 00 00 */ li r11, 0 -/* 80008FC4 00005DC4 A0 05 00 04 */ lhz r0, 4(r5) -/* 80008FC8 00005DC8 7D 48 53 78 */ mr r8, r10 -/* 80008FCC 00005DCC 7D 47 53 78 */ mr r7, r10 -/* 80008FD0 00005DD0 B0 04 00 04 */ sth r0, 4(r4) -/* 80008FD4 00005DD4 91 84 00 08 */ stw r12, 8(r4) -/* 80008FD8 00005DD8 A0 05 00 04 */ lhz r0, 4(r5) -/* 80008FDC 00005DDC 54 00 30 32 */ slwi r0, r0, 6 -/* 80008FE0 00005DE0 7D 8C 02 14 */ add r12, r12, r0 -/* 80008FE4 00005DE4 48 00 00 4C */ b lbl_80009030 -lbl_80008FE8: -/* 80008FE8 00005DE8 80 C4 00 08 */ lwz r6, 8(r4) -/* 80008FEC 00005DEC 38 0A 00 28 */ addi r0, r10, 0x28 -/* 80008FF0 00005DF0 39 2A 00 34 */ addi r9, r10, 0x34 -/* 80008FF4 00005DF4 7C 86 01 2E */ stwx r4, r6, r0 -/* 80008FF8 00005DF8 80 C5 00 08 */ lwz r6, 8(r5) -/* 80008FFC 00005DFC 7C 06 48 2E */ lwzx r0, r6, r9 -/* 80009000 00005E00 28 00 00 00 */ cmplwi r0, 0 -/* 80009004 00005E04 41 82 00 1C */ beq lbl_80009020 -/* 80009008 00005E08 80 C4 00 08 */ lwz r6, 8(r4) -/* 8000900C 00005E0C 7D 86 49 2E */ stwx r12, r6, r9 -/* 80009010 00005E10 91 0C 00 34 */ stw r8, 0x34(r12) -/* 80009014 00005E14 90 8C 00 28 */ stw r4, 0x28(r12) -/* 80009018 00005E18 39 8C 00 40 */ addi r12, r12, 0x40 -/* 8000901C 00005E1C 48 00 00 0C */ b lbl_80009028 -lbl_80009020: -/* 80009020 00005E20 80 C4 00 08 */ lwz r6, 8(r4) -/* 80009024 00005E24 7C E6 49 2E */ stwx r7, r6, r9 -lbl_80009028: -/* 80009028 00005E28 39 4A 00 40 */ addi r10, r10, 0x40 -/* 8000902C 00005E2C 39 6B 00 01 */ addi r11, r11, 1 -lbl_80009030: -/* 80009030 00005E30 A0 05 00 04 */ lhz r0, 4(r5) -/* 80009034 00005E34 7C 0B 00 00 */ cmpw r11, r0 -/* 80009038 00005E38 41 80 FF B0 */ blt lbl_80008FE8 -/* 8000903C 00005E3C 39 20 00 00 */ li r9, 0 -/* 80009040 00005E40 7D 8B 63 78 */ mr r11, r12 -/* 80009044 00005E44 7D 28 4B 78 */ mr r8, r9 -/* 80009048 00005E48 48 00 00 60 */ b lbl_800090A8 -lbl_8000904C: -/* 8000904C 00005E4C 80 E4 00 08 */ lwz r7, 8(r4) -/* 80009050 00005E50 38 00 00 00 */ li r0, 0 -/* 80009054 00005E54 80 C5 00 08 */ lwz r6, 8(r5) -/* 80009058 00005E58 7C E7 42 14 */ add r7, r7, r8 -/* 8000905C 00005E5C 7D 46 42 14 */ add r10, r6, r8 -/* 80009060 00005E60 48 00 00 38 */ b lbl_80009098 -lbl_80009064: -/* 80009064 00005E64 80 CA 00 1C */ lwz r6, 0x1c(r10) -/* 80009068 00005E68 90 C7 00 1C */ stw r6, 0x1c(r7) -/* 8000906C 00005E6C 80 CA 00 1C */ lwz r6, 0x1c(r10) -/* 80009070 00005E70 28 06 00 00 */ cmplwi r6, 0 -/* 80009074 00005E74 41 82 00 18 */ beq lbl_8000908C -/* 80009078 00005E78 91 67 00 24 */ stw r11, 0x24(r7) -/* 8000907C 00005E7C 80 CA 00 1C */ lwz r6, 0x1c(r10) -/* 80009080 00005E80 54 C6 18 38 */ slwi r6, r6, 3 -/* 80009084 00005E84 7D 6B 32 14 */ add r11, r11, r6 -/* 80009088 00005E88 48 00 00 08 */ b lbl_80009090 -lbl_8000908C: -/* 8000908C 00005E8C 90 07 00 24 */ stw r0, 0x24(r7) -lbl_80009090: -/* 80009090 00005E90 81 4A 00 34 */ lwz r10, 0x34(r10) -/* 80009094 00005E94 80 E7 00 34 */ lwz r7, 0x34(r7) -lbl_80009098: -/* 80009098 00005E98 28 07 00 00 */ cmplwi r7, 0 -/* 8000909C 00005E9C 40 82 FF C8 */ bne lbl_80009064 -/* 800090A0 00005EA0 39 08 00 40 */ addi r8, r8, 0x40 -/* 800090A4 00005EA4 39 29 00 01 */ addi r9, r9, 1 -lbl_800090A8: -/* 800090A8 00005EA8 A0 04 00 04 */ lhz r0, 4(r4) -/* 800090AC 00005EAC 7C 09 00 00 */ cmpw r9, r0 -/* 800090B0 00005EB0 41 80 FF 9C */ blt lbl_8000904C -/* 800090B4 00005EB4 90 64 00 14 */ stw r3, 0x14(r4) -/* 800090B8 00005EB8 4E 80 00 20 */ blr - .global xAnimPoolInit__FP8xMemPoolUiUiUiUi xAnimPoolInit__FP8xMemPoolUiUiUiUi: /* 800090BC 00005EBC 94 21 FF E0 */ stwu r1, -0x20(r1) @@ -4249,72 +3002,6 @@ lbl_8000928C: /* 800092CC 000060CC 38 21 00 20 */ addi r1, r1, 0x20 /* 800092D0 000060D0 4E 80 00 20 */ blr -.global xAnimPoolAlloc__FP8xMemPoolPvP10xAnimTableP14xModelInstance -xAnimPoolAlloc__FP8xMemPoolPvP10xAnimTableP14xModelInstance: -/* 800092D4 000060D4 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 800092D8 000060D8 7C 08 02 A6 */ mflr r0 -/* 800092DC 000060DC 90 01 00 24 */ stw r0, 0x24(r1) -/* 800092E0 000060E0 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 800092E4 000060E4 7C 9F 23 78 */ mr r31, r4 -/* 800092E8 000060E8 93 C1 00 18 */ stw r30, 0x18(r1) -/* 800092EC 000060EC 7C DE 33 78 */ mr r30, r6 -/* 800092F0 000060F0 93 A1 00 14 */ stw r29, 0x14(r1) -/* 800092F4 000060F4 7C BD 2B 78 */ mr r29, r5 -/* 800092F8 000060F8 48 02 AA 3D */ bl xMemPoolAlloc__FP8xMemPool -/* 800092FC 000060FC 7F E4 FB 78 */ mr r4, r31 -/* 80009300 00006100 7C 7F 1B 78 */ mr r31, r3 -/* 80009304 00006104 7F A5 EB 78 */ mr r5, r29 -/* 80009308 00006108 7F C6 F3 78 */ mr r6, r30 -/* 8000930C 0000610C 4B FF F5 01 */ bl xAnimPlaySetup__FP9xAnimPlayPvP10xAnimTableP14xModelInstance -/* 80009310 00006110 80 01 00 24 */ lwz r0, 0x24(r1) -/* 80009314 00006114 7F E3 FB 78 */ mr r3, r31 -/* 80009318 00006118 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 8000931C 0000611C 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 80009320 00006120 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 80009324 00006124 7C 08 03 A6 */ mtlr r0 -/* 80009328 00006128 38 21 00 20 */ addi r1, r1, 0x20 -/* 8000932C 0000612C 4E 80 00 20 */ blr - -.global xAnimPoolFree__FP9xAnimPlay -xAnimPoolFree__FP9xAnimPlay: -/* 80009330 00006130 94 21 FF E0 */ stwu r1, -0x20(r1) -/* 80009334 00006134 7C 08 02 A6 */ mflr r0 -/* 80009338 00006138 90 01 00 24 */ stw r0, 0x24(r1) -/* 8000933C 0000613C 93 E1 00 1C */ stw r31, 0x1c(r1) -/* 80009340 00006140 3B E0 00 00 */ li r31, 0 -/* 80009344 00006144 93 C1 00 18 */ stw r30, 0x18(r1) -/* 80009348 00006148 3B C0 00 00 */ li r30, 0 -/* 8000934C 0000614C 93 A1 00 14 */ stw r29, 0x14(r1) -/* 80009350 00006150 7C 7D 1B 78 */ mr r29, r3 -/* 80009354 00006154 48 00 00 30 */ b lbl_80009384 -lbl_80009358: -/* 80009358 00006158 80 1D 00 08 */ lwz r0, 8(r29) -/* 8000935C 0000615C 7C 60 FA 14 */ add r3, r0, r31 -/* 80009360 00006160 4B FF E9 E5 */ bl EffectSingleStop__FP11xAnimSingle -/* 80009364 00006164 80 7D 00 08 */ lwz r3, 8(r29) -/* 80009368 00006168 38 1F 00 34 */ addi r0, r31, 0x34 -/* 8000936C 0000616C 7C 63 00 2E */ lwzx r3, r3, r0 -/* 80009370 00006170 28 03 00 00 */ cmplwi r3, 0 -/* 80009374 00006174 41 82 00 08 */ beq lbl_8000937C -/* 80009378 00006178 4B FF E9 CD */ bl EffectSingleStop__FP11xAnimSingle -lbl_8000937C: -/* 8000937C 0000617C 3B FF 00 40 */ addi r31, r31, 0x40 -/* 80009380 00006180 3B DE 00 01 */ addi r30, r30, 1 -lbl_80009384: -/* 80009384 00006184 A0 1D 00 04 */ lhz r0, 4(r29) -/* 80009388 00006188 7C 1E 00 40 */ cmplw r30, r0 -/* 8000938C 0000618C 41 80 FF CC */ blt lbl_80009358 -/* 80009390 00006190 80 7D 00 14 */ lwz r3, 0x14(r29) -/* 80009394 00006194 7F A4 EB 78 */ mr r4, r29 -/* 80009398 00006198 48 02 AA 39 */ bl xMemPoolFree__FP8xMemPoolPv -/* 8000939C 0000619C 80 01 00 24 */ lwz r0, 0x24(r1) -/* 800093A0 000061A0 83 E1 00 1C */ lwz r31, 0x1c(r1) -/* 800093A4 000061A4 83 C1 00 18 */ lwz r30, 0x18(r1) -/* 800093A8 000061A8 83 A1 00 14 */ lwz r29, 0x14(r1) -/* 800093AC 000061AC 7C 08 03 A6 */ mtlr r0 -/* 800093B0 000061B0 38 21 00 20 */ addi r1, r1, 0x20 -/* 800093B4 000061B4 4E 80 00 20 */ blr - .global xAnimFileRawTime__FP9xAnimFilef xAnimFileRawTime__FP9xAnimFilef: /* 800093B8 000061B8 80 83 00 0C */ lwz r4, 0xc(r3)